RL_Parallel_GC.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "qlhz2Mk8SM1m",
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Prepare"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 3.9.13\n"
     ]
    }
   ],
   "source": [
    "! python3 -V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "! pip install -r requirements.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "8nNIAJjqGGJF",
    "outputId": "264b42c1-ab6a-40d8-8e4a-2d71815ed52c"
   },
   "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": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fa03qYh4AuUO",
    "outputId": "58a0ee89-1e69-497a-ea40-8482603bb309"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "IMPORTANT NOTICE:  This is NOT a release build of the DaCapo suite.\n",
      "Since it is not an official release of the DaCapo suite, care must be taken when\n",
      "using the suite, and any use of the build must be sure to note that it is not an\n",
      "offical release, and should note the relevant git hash.\n",
      "\n",
      "Feedback is greatly appreciated.   The preferred mode of feedback is via github.\n",
      "Please use our github page to create an issue or a pull request.\n",
      "    https://github.com/dacapobench/dacapobench.\n",
      "--------------------------------------------------------------------------------\n",
      "\n",
      "avrora batik biojava cassandra eclipse fop graphchi h2 jme jython kafka luindex lusearch pmd spring sunflow tomcat tradebeans tradesoap xalan zxing\n"
     ]
    }
   ],
   "source": [
    "! ./jdk-11.0.20/bin/java -jar dacapo/dacapochopin.jar -l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using scaled threading model. 48 processors detected, 48 threads used to drive the workload, in a possible range of [1,100]\n",
      "===== DaCapo 9.12-MR1 xalan starting =====\n",
      "Normal completion.\n",
      "===== DaCapo 9.12-MR1 xalan PASSED in 1338 msec =====\n"
     ]
    }
   ],
   "source": [
    "!  ./jdk-11.0.20/bin/java -jar dacapo-bench.jar xalan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "2HP3ZuMjGyn7",
    "outputId": "5ee074ed-7625-4327-93dd-aa7d3c463747"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class name: org.dacapo.harness.Xalan\n",
      "Configurations:\n",
      "short     An XSLT processor for transforming XML documents\n",
      "long      Xalan repeatedly transforms a set of XML documents\n",
      "author    Apache Software Foundation\n",
      "license   Apache License, Version 2.0\n",
      "copyright Copyright (C) 1999-2003 The Apache Software Foundation\n",
      "url       http://xml.apache.org/xalan-j/\n",
      "version   2.7.1\n",
      "sizes     default large small\n",
      "Using scaled threading model. 48 processors detected, 48 threads used to drive the workload, in a possible range of [1,100]\n",
      "===== DaCapo 9.12-MR1 xalan starting warmup 1 =====\n",
      "Normal completion.\n",
      "===== DaCapo 9.12-MR1 xalan completed warmup 1 in 1163 msec =====\n",
      "===== DaCapo 9.12-MR1 xalan starting warmup 2 =====\n",
      "Normal completion.\n",
      "===== DaCapo 9.12-MR1 xalan completed warmup 2 in 213 msec =====\n",
      "===== DaCapo 9.12-MR1 xalan starting warmup 3 =====\n",
      "Normal completion.\n",
      "===== DaCapo 9.12-MR1 xalan completed warmup 3 in 196 msec =====\n",
      "===== DaCapo 9.12-MR1 xalan starting warmup 4 =====\n",
      "Normal completion.\n",
      "===== DaCapo 9.12-MR1 xalan completed warmup 4 in 196 msec =====\n",
      "===== DaCapo 9.12-MR1 xalan starting =====\n",
      "Normal completion.\n",
      "===== DaCapo 9.12-MR1 xalan PASSED in 204 msec =====\n"
     ]
    }
   ],
   "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": null,
   "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"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GCViewer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sep 11, 2023 1:07:56 PM com.tagtraum.perf.gcviewer.GCViewer doMain\n",
      "INFO: GCViewer command line mode\n",
      "Sep 11, 2023 1:07:56 PM com.tagtraum.perf.gcviewer.imp.DataReaderFacade loadModel\n",
      "INFO: GCViewer version 1.36 (2019-11-30T21:36:26+0000)\n",
      "Sep 11, 2023 1:07:56 PM com.tagtraum.perf.gcviewer.imp.DataReaderFactory getDataReaderBySample\n",
      "INFO: File format: Oracle / OpenJDK unified jvm logging\n",
      "Sep 11, 2023 1:07:56 PM com.tagtraum.perf.gcviewer.imp.DataReaderUnifiedJvmLogging read\n",
      "INFO: Reading Oracle / OpenJDK unified jvm logging format...\n",
      "Sep 11, 2023 1:07:56 PM com.tagtraum.perf.gcviewer.imp.DataReaderUnifiedJvmLogging lineContainsParseableEvent\n",
      "INFO:  Using Parallel\n",
      "Sep 11, 2023 1:07:56 PM com.tagtraum.perf.gcviewer.imp.DataReaderUnifiedJvmLogging read\n",
      "INFO: Reading done.\n",
      "Sep 11, 2023 1:07:56 PM com.tagtraum.perf.gcviewer.GCViewer doMain\n",
      "INFO: export completed successfully\n"
     ]
    }
   ],
   "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"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Main"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 3.10.0\n"
     ]
    }
   ],
   "source": [
    "! python -V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "BwafqfLmSm_s"
   },
   "outputs": [],
   "source": [
    "! export PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=python\n",
    "\n",
    "import requests\n",
    "import json\n",
    "import logging\n",
    "import warnings\n",
    "import numpy as np\n",
    "from typing import List\n",
    "from gym.spaces import Discrete, Box\n",
    "import JVMEnv, JVMEnvTest\n",
    "from tqdm import tqdm \n",
    "\n",
    "warnings.filterwarnings(action=\"ignore\")\n",
    "\n",
    "# GCEasy API Key\n",
    "API_KEY = \"af176fbc-7be2-4fc5-8b31-5624956845c6\"\n",
    "\n",
    "# JDK used for benchmarking\n",
    "TEST_JDK_PATH = \"/home/ellkrauze/projects/gc-ml/jdk-11.0.20\"\n",
    "\n",
    "# DaCapo benchmark name\n",
    "BM = \"batik\"\n",
    "\n",
    "BM_PATH = \"dacapo-bench.jar\"\n",
    "\n",
    "# Number of benchmark's iterations in total\n",
    "NUM_ITER = 5\n",
    "\n",
    "# Name of the output file (Garbage Collector logs)\n",
    "GC_LOG_FILE = f\"gc-{BM}.txt\"\n",
    "\n",
    "# JVM option to perform action to (increase, leave, decrease)\n",
    "JVM_OPT_NAME = \"MaxHeapSize\"\n",
    "# Maximum heap size array (from 256m to 4G)\n",
    "JVM_OPT_RANGE = [np.array([268435456]), np.array([4294967296])]\n",
    "\n",
    "\"\"\"\n",
    "What to optimize: our goal in performance tuning.\n",
    "This is a JSON field which is extracted from GC log file\n",
    "using GCEasy API (https://blog.gceasy.io/2016/06/18/garbage-collection-log-analysis-api/).\n",
    "\"\"\"\n",
    "# GOAL = \"throughputPercentage\"\n",
    "GOAL = \"fullGCMaxTime\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 391
    },
    "id": "L3o-iVZeSrKE",
    "outputId": "25102eb5-2949-416d-a420-5b84bdcf2310"
   },
   "outputs": [],
   "source": [
    "# env = JVMEnv.JVMEnv(\n",
    "#     jdk = TEST_JDK_PATH, \n",
    "#     bm_path = BM_PATH,\n",
    "#     jvm_opt_name = JVM_OPT_NAME,\n",
    "#     jvm_opt_range = JVM_OPT_RANGE,\n",
    "#     bm = BM,\n",
    "#     n = NUM_ITER,\n",
    "#     goal = GOAL,\n",
    "#     api_key = API_KEY\n",
    "# )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Plot Xmx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 39/39 [06:48<00:00, 10.47s/it]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "fullgc_values = []\n",
    "minorgc_values = []\n",
    "heap_values = []\n",
    "\n",
    "for Xmx in tqdm(range(268435456, 4294967296, 100 * (2**10) * (2**10))):\n",
    "    env._run(\n",
    "        jvm_opts = [f\"-XX:MaxHeapSize={Xmx}\"], \n",
    "        gc_log_file = GC_LOG_FILE, \n",
    "        bm = BM, \n",
    "        bm_path = BM_PATH, \n",
    "        n = NUM_ITER\n",
    "    )\n",
    "    \n",
    "    fullgc_value = env._get_goal_value(\n",
    "        goal_name = \"fullGCMaxTime\", \n",
    "        gc_log_file = GC_LOG_FILE, \n",
    "        api_key = API_KEY\n",
    "    )\n",
    "\n",
    "    minorgc_value = env._get_goal_value(\n",
    "        goal_name = \"minorGCMaxTime\", \n",
    "        gc_log_file = GC_LOG_FILE, \n",
    "        api_key = API_KEY\n",
    "    )\n",
    "\n",
    "    fullgc_values.append(fullgc_value)\n",
    "    minorgc_values.append(minorgc_value)\n",
    "    heap_values.append(Xmx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 39/39 [01:41<00:00,  2.61s/it]\n",
      "100%|██████████| 39/39 [01:51<00:00,  2.87s/it]\n",
      "100%|██████████| 39/39 [01:50<00:00,  2.83s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x1000 with 15 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def get_goal_value(goal_name: str, gc_log_file: str, api_key: str, verbose: bool=False):\n",
    "\n",
    "    gceasy_url = f\"https://api.gceasy.io/analyzeGC?apiKey={api_key}&normalizeUnits=true\"\n",
    "    gc_logfile = {\"upload_file\": open(gc_log_file, 'rb')}\n",
    "    headers = {\"Content-Type\": \"text\"}\n",
    "\n",
    "    response = requests.post(gceasy_url, files=gc_logfile, headers=headers)\n",
    "    gc_info = json.loads(response.text)\n",
    "    goal_value = gc_info[goal_name]\n",
    "\n",
    "    if verbose: logging.debug(f\"{goal_name} = {goal_value}\")\n",
    "\n",
    "    return float(goal_value)\n",
    "\n",
    "bms = [\"avrora\",\"batik\",\"eclipse\", \"fop\", \"h2\", \"jython\", \"luindex\", \"lusearch\", \"lusearch-fix\", \"pmd\", \"sunflow\", \"tomcat\", \"tradebeans\", \"tradesoap\", \"xalan\"]\n",
    "\n",
    "fig, axs = plt.subplots(3, 5, figsize=(20, 10))\n",
    "fig.subplots_adjust(hspace = .5, wspace=.001)\n",
    "\n",
    "axs = axs.ravel()\n",
    "\n",
    "# for i in range(len(bms)):\n",
    "for i in range(3):\n",
    "\n",
    "    # Measurements\n",
    "    gc_values = []\n",
    "    heap_values = []\n",
    "\n",
    "    for Xmx in tqdm(range(268435456, 4294967296, 100 * (2**10) * (2**10))):\n",
    "        env._run(\n",
    "            jvm_opts = [f\"-XX:MaxHeapSize={Xmx}\"], \n",
    "            gc_log_file = GC_LOG_FILE, \n",
    "            bm = BM, \n",
    "            bm_path = BM_PATH, \n",
    "            n = 3\n",
    "        )\n",
    "        \n",
    "        gc_value = get_goal_value(\n",
    "            goal_name = \"throughputPercentage\", \n",
    "            gc_log_file = GC_LOG_FILE, \n",
    "            api_key = API_KEY\n",
    "        )\n",
    "\n",
    "        gc_values.append(gc_value)\n",
    "        heap_values.append(Xmx)\n",
    "    \n",
    "    # Plots\n",
    "    axs[i].plot(heap_values, gc_values, label='throughputPercentage')\n",
    "    axs[i].legend(fontsize = 5)\n",
    "    axs[i].set_xlabel(JVM_OPT_NAME, fontsize = 10)\n",
    "    axs[i].set_title(bms[i], fontsize = 10)\n",
    "\n",
    "# plt.plot(heap_values, fullgc_values, label='minorGCMaxTime')\n",
    "# plt.plot(heap_values, minorgc_values, label='fullGCMaxTime')\n",
    "# plt.legend()\n",
    "# plt.xlabel(JVM_OPT_NAME)\n",
    "# plt.title(BM)\n",
    "# plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "iCl11d9QStqP",
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "# Deep Learning Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "env = JVMEnvTest.JVMEnvTest()\n",
    "\n",
    "states = env.observation_space.shape\n",
    "actions = env.action_space.n\n",
    "\n",
    "print(states)\n",
    "print(actions)\n",
    "\n",
    "model = build_model(states, actions)\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# episodes = 3\n",
    "# for episode in tqdm(range(1, episodes+1)):\n",
    "#     state = env.reset()\n",
    "#     done = False\n",
    "#     score = 0\n",
    "\n",
    "#     while not done:\n",
    "#         env.render(mode=\"human\")\n",
    "#         action = env.action_space.sample()\n",
    "#         n_state, reward, done, info = env.step(action)\n",
    "#         score+=reward\n",
    "#     #     print(info)\n",
    "#     #     print(f\"Score: {score}\")\n",
    "#     # print('Episode:{} Score:{}'.format(episode, score))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tensorflow DQN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import dill\n",
    "# dill.load_session('notebook_env.db')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-10-13 09:48:49.324453: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-10-13 09:48:49.361024: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-10-13 09:48:49.361681: 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-13 09:48:50.100082: 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",
    "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 # !!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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",
    "train_env = tf_py_environment.TFPyEnvironment(env, isolation=True)\n",
    "eval_env = tf_py_environment.TFPyEnvironment(env, isolation=True)\n",
    "\n",
    "test_env = tf_py_environment.TFPyEnvironment(\n",
    "    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",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fc_layer_params = (100, 50)\n",
    "# fc_layer_params = (100, 50, 24)\n",
    "fc_layer_params = (100, 75, 50)\n",
    "action_tensor_spec = tensor_spec.from_spec(env.action_spec())\n",
    "num_actions = action_tensor_spec.maximum - action_tensor_spec.minimum + 1\n",
    "\n",
    "def dense_layer(num_units):\n",
    "    \"\"\"\n",
    "    Define a helper function to create Dense layers configured \n",
    "    with the right activation and kernel initializer.\n",
    "    \"\"\"\n",
    "    return tf.keras.layers.Dense(\n",
    "        num_units,\n",
    "        activation=tf.keras.activations.relu,\n",
    "        kernel_initializer=tf.keras.initializers.VarianceScaling(\n",
    "            scale=2.0, mode='fan_in', distribution='truncated_normal'))\n",
    "\n",
    "# QNetwork consists of a sequence of Dense layers followed by a dense layer\n",
    "# with `num_actions` units to generate one q_value per available action as\n",
    "# its output.\n",
    "dense_layers = [dense_layer(num_units) for num_units in fc_layer_params]\n",
    "q_values_layer = tf.keras.layers.Dense(\n",
    "    num_actions,\n",
    "    activation=None,\n",
    "    kernel_initializer=tf.keras.initializers.RandomUniform(\n",
    "        minval=-0.03, maxval=0.03),\n",
    "    bias_initializer=tf.keras.initializers.Constant(-0.2))\n",
    "q_net = sequential.Sequential(dense_layers + [q_values_layer])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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",
    "# replay_buffer_capacity = 10000\n",
    "\n",
    "# fc_layer_params = (100,)\n",
    "\n",
    "# batch_size = 64  # @param {type:\"integer\"}\n",
    "batch_size = 128  # @param {type:\"integer\"}\n",
    "# batch_size = 64  # @param {type:\"integer\"}\n",
    "# learning_rate = 1e-3  # @param {type:\"number\"}\n",
    "learning_rate = 1e-6\n",
    "# learning_rate = 1e-7\n",
    "# gamma = 0.99\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_step_update = 1  # @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",
    "optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=learning_rate)\n",
    "train_step_counter = tf.Variable(0)\n",
    "global_step = tf.compat.v1.train.get_or_create_global_step()\n",
    "\n",
    "agent = dqn_agent.DqnAgent(\n",
    "  train_env.time_step_spec(),\n",
    "  train_env.action_spec(),\n",
    "  q_network=q_net,\n",
    "  optimizer=optimizer,\n",
    "  n_step_update=n_step_update,\n",
    "  td_errors_loss_fn=tf.keras.losses.MeanSquaredError(),\n",
    "  epsilon_greedy=None,\n",
    "  boltzmann_temperature=0.1, # !\n",
    "  target_update_period=target_update_period, # ??\n",
    "  gamma=gamma,\n",
    "  gradient_clipping=gradient_clipping, # [-1, 1]\n",
    "  train_step_counter=global_step\n",
    ")\n",
    "\n",
    "\n",
    "  # epsilon_greedy=0.9, # a probability of choosing a random action\n",
    "\n",
    "agent.initialize()\n",
    "\n",
    "random_policy = random_tf_policy.RandomTFPolicy(\n",
    "  time_step_spec = train_env.time_step_spec(),\n",
    "  action_spec = train_env.action_spec(),\n",
    "  automatic_state_reset=True,\n",
    "  clip=False\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Collection\n",
    "\n",
    "In order to keep track of the data collected from the environment, we will use a replay buffer. It stores experience data when we collect trajectories and is consumed during training.\n",
    "\n",
    "This replay buffer is constructed using specs describing the tensors that are to be stored, which can be obtained from the agent using `agent.collect_data_spec`.\n",
    "\n",
    "Set up the replay buffer and the initial data collection with the random policy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def collect_step(environment, policy):\n",
    "    time_step = environment.current_time_step()\n",
    "    action_step = policy.action(time_step)\n",
    "    reward = 0\n",
    "    try:\n",
    "        next_time_step = environment.step(action_step.action)\n",
    "        reward = next_time_step.reward\n",
    "        traj = trajectory.from_transition(time_step, action_step, next_time_step)\n",
    "        replay_buffer.add_batch(traj)\n",
    "        trajectories.append([traj.observation, env._reward])\n",
    "    except ValueError:\n",
    "        pass\n",
    "    return reward\n",
    "\n",
    "\n",
    "def save_dataset(data, path):\n",
    "    step_counter = tf.Variable(0, trainable=False)\n",
    "    checkpoint_prefix = \"checkpoint\"\n",
    "    checkpoint_args = {\n",
    "        \"checkpoint_interval\": 50,\n",
    "        \"step_counter\": step_counter,\n",
    "        \"directory\": checkpoint_prefix,\n",
    "        \"max_to_keep\": 3,\n",
    "    }\n",
    "    try:\n",
    "        data.save(path, checkpoint_args=checkpoint_args)\n",
    "    except:\n",
    "        pass\n",
    "\n",
    "def save_rb(replay_buffer, path):\n",
    "    tf.train.Checkpoint(rb = replay_buffer).save(path)\n",
    "\n",
    "def restore_rb(replay_buffer, path):\n",
    "    tf.train.Checkpoint(rb = replay_buffer).restore(path)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10000/10000 [00:45<00:00, 217.50it/s]\n"
     ]
    }
   ],
   "source": [
    "replay_buffer = tf_uniform_replay_buffer.TFUniformReplayBuffer(\n",
    "    data_spec=agent.collect_data_spec,\n",
    "    batch_size=train_env.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",
    "\n",
    "collect_dataset = True\n",
    "trajectories = []\n",
    "\n",
    "if collect_dataset:\n",
    "    for _ in tqdm(range(initial_collect_steps)):\n",
    "        collect_step(train_env, random_policy)\n",
    "    save_rb(replay_buffer, dataset_path)\n",
    "else: \n",
    "    restore_rb(replay_buffer, dataset_path+'-1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/vsakovskaya/my-env/lib/python3.9/site-packages/tf_agents/replay_buffers/tf_uniform_replay_buffer.py:342: CounterV2 (from tensorflow.python.data.experimental.ops.counter) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use `tf.data.Dataset.counter(...)` instead.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/vsakovskaya/my-env/lib/python3.9/site-packages/tf_agents/replay_buffers/tf_uniform_replay_buffer.py:342: CounterV2 (from tensorflow.python.data.experimental.ops.counter) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use `tf.data.Dataset.counter(...)` instead.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/vsakovskaya/my-env/lib/python3.9/site-packages/tensorflow/python/autograph/impl/api.py:377: ReplayBuffer.get_next (from tf_agents.replay_buffers.replay_buffer) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use `as_dataset(..., single_deterministic_pass=False) instead.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/vsakovskaya/my-env/lib/python3.9/site-packages/tensorflow/python/autograph/impl/api.py:377: ReplayBuffer.get_next (from tf_agents.replay_buffers.replay_buffer) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use `as_dataset(..., single_deterministic_pass=False) instead.\n"
     ]
    }
   ],
   "source": [
    "dataset = replay_buffer.as_dataset(\n",
    "    num_parallel_calls=3, \n",
    "    sample_batch_size=batch_size,\n",
    "    num_steps=n_step_update + 1, \n",
    "    single_deterministic_pass=False).prefetch(3)\n",
    "\n",
    "# dataset = replay_buffer.as_dataset(\n",
    "#     num_parallel_calls=3,\n",
    "#     sample_batch_size=batch_size,\n",
    "#     num_steps=2).prefetch(3)\n",
    "\n",
    "iterator = iter(dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: title={'center': 'Frequency of flag pairs in a dataset'}, xlabel='MaxTenuringThreshold,ParallelGCThreads'>"
      ]
     },
     "execution_count": 14,
     "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": 15,
   "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": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_43569/857763126.py:9: FutureWarning: In a future version of pandas all arguments of DataFrame.pivot will be keyword-only.\n",
      "  data_pivoted = data.pivot(\"MaxTenuringThreshold\", \"ParallelGCThreads\", \"Average GC Pause\")\n"
     ]
    },
    {
     "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()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agent Training\n",
    "\n",
    "The training loop involves both collecting data from the environment and optimizing the agent's networks. Along the way, we will occasionally evaluate the agent's policy to see how we are doing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also need an `optimizer` to train the network we just created, and a `train_step_counter` variable to keep track of how many times the network was updated.\n",
    "\n",
    "Note that one other significant difference from vanilla `DqnAgent` is that we now need to specify `min_q_value` and `max_q_value` as arguments. These specify the most extreme values of the support (in other words, the most extreme of the 51 atoms on either side). Make sure to choose these appropriately for your particular environment. Here we use -20 and 20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_avg_return(environment, policy, num_episodes=10):\n",
    "\n",
    "  total_return = 0.0\n",
    "  time_step = environment.reset()\n",
    "  episode_return = 0.0\n",
    "  for _ in tqdm(range(num_episodes)):\n",
    "\n",
    "    action_step = policy.action(time_step, seed=42)\n",
    "    time_step = environment.step(action_step.action)\n",
    "    # print(f\"time_step = {time_step.observation}\")\n",
    "    episode_return += time_step.reward\n",
    "    total_return += episode_return\n",
    "\n",
    "  avg_return = total_return / num_episodes\n",
    "  return avg_return.numpy()[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/50000 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/vsakovskaya/my-env/lib/python3.9/site-packages/tensorflow/python/util/dispatch.py:1176: calling foldr_v2 (from tensorflow.python.ops.functional_ops) with back_prop=False is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "back_prop=False is deprecated. Consider using tf.stop_gradient instead.\n",
      "Instead of:\n",
      "results = tf.foldr(fn, elems, back_prop=False)\n",
      "Use:\n",
      "results = tf.nest.map_structure(tf.stop_gradient, tf.foldr(fn, elems))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/vsakovskaya/my-env/lib/python3.9/site-packages/tensorflow/python/util/dispatch.py:1176: calling foldr_v2 (from tensorflow.python.ops.functional_ops) with back_prop=False is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "back_prop=False is deprecated. Consider using tf.stop_gradient instead.\n",
      "Instead of:\n",
      "results = tf.foldr(fn, elems, back_prop=False)\n",
      "Use:\n",
      "results = tf.nest.map_structure(tf.stop_gradient, tf.foldr(fn, elems))\n",
      "  0%|          | 105/50000 [00:03<16:49, 49.42it/s] "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 100: loss = 7.599503517150879\n",
      "step = 100: Average reward = -0.33000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 206/50000 [00:05<16:10, 51.33it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 200: loss = 7.994638442993164\n",
      "step = 200: Average reward = -0.34000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|          | 310/50000 [00:07<16:51, 49.14it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 300: loss = 7.42820930480957\n",
      "step = 300: Average reward = -0.33000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|          | 409/50000 [00:09<17:30, 47.18it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 400: loss = 6.058167457580566\n",
      "step = 400: Average reward = -0.33000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|          | 509/50000 [00:11<16:45, 49.23it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 500: loss = 6.243966102600098\n",
      "step = 500: Average reward = -0.34000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|          | 610/50000 [00:13<15:14, 54.01it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 600: loss = 6.646970272064209\n",
      "step = 600: Average reward = -0.33000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|▏         | 710/50000 [00:15<16:18, 50.36it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 700: loss = 5.249920845031738\n",
      "step = 700: Average reward = -0.33000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  2%|▏         | 807/50000 [00:17<15:59, 51.29it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 800: loss = 5.015242099761963\n",
      "step = 800: Average reward = -0.34000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  2%|▏         | 906/50000 [00:19<17:36, 46.46it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 900: loss = 4.545398712158203\n",
      "step = 900: Average reward = -0.33000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  2%|▏         | 1007/50000 [00:21<16:23, 49.82it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 1000: loss = 4.032285690307617\n",
      "step = 1000: Average reward = -0.33000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  2%|▏         | 1107/50000 [00:23<16:15, 50.12it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 1100: loss = 3.778931140899658\n",
      "step = 1100: Average reward = -0.34000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  2%|▏         | 1205/50000 [00:25<16:07, 50.41it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 1200: loss = 4.130570411682129\n",
      "step = 1200: Average reward = -0.33000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  3%|▎         | 1307/50000 [00:27<17:33, 46.23it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 1300: loss = 3.248626470565796\n",
      "step = 1300: Average reward = -0.33000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  3%|▎         | 1407/50000 [00:29<16:19, 49.61it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 1400: loss = 3.073330879211426\n",
      "step = 1400: Average reward = -0.34000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  3%|▎         | 1505/50000 [00:31<17:42, 45.64it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 1500: loss = 3.0926403999328613\n",
      "step = 1500: Average reward = -0.33000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  3%|▎         | 1607/50000 [00:33<17:57, 44.91it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 1600: loss = 3.0480239391326904\n",
      "step = 1600: Average reward = -0.33000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  3%|▎         | 1705/50000 [00:35<17:24, 46.23it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 1700: loss = 2.5787994861602783\n",
      "step = 1700: Average reward = -0.34000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  4%|▎         | 1809/50000 [00:37<14:15, 56.32it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 1800: loss = 2.5243043899536133\n",
      "step = 1800: Average reward = -0.76000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  4%|▍         | 1906/50000 [00:39<16:27, 48.72it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 1900: loss = 2.0735814571380615\n",
      "step = 1900: Average reward = -1.00000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  4%|▍         | 2007/50000 [00:41<15:24, 51.92it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 2000: loss = 1.9013681411743164\n",
      "step = 2000: Average reward = -1.00000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  4%|▍         | 2109/50000 [00:43<14:57, 53.35it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 2100: loss = 1.635307788848877\n",
      "step = 2100: Average reward = -1.00000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  4%|▍         | 2206/50000 [00:45<15:53, 50.13it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 2200: loss = 1.4537999629974365\n",
      "step = 2200: Average reward = -1.00000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|▍         | 2307/50000 [00:47<15:05, 52.66it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 2300: loss = 1.2146382331848145\n",
      "step = 2300: Average reward = -1.00000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|▍         | 2406/50000 [00:49<14:46, 53.69it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 2400: loss = 1.2369282245635986\n",
      "step = 2400: Average reward = -1.00000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|▌         | 2508/50000 [00:51<16:05, 49.19it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 2500: loss = 0.937963604927063\n",
      "step = 2500: Average reward = -1.00000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|▌         | 2608/50000 [00:53<17:13, 45.84it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 2600: loss = 0.8926867842674255\n",
      "step = 2600: Average reward = -0.98596\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|▌         | 2710/50000 [00:55<14:59, 52.58it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 2700: loss = 0.7207755446434021\n",
      "step = 2700: Average reward = -0.07988\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  6%|▌         | 2810/50000 [00:57<15:21, 51.22it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 2800: loss = 0.8380323052406311\n",
      "step = 2800: Average reward = 0.03004\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  6%|▌         | 2906/50000 [00:59<14:58, 52.43it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 2900: loss = 0.7181098461151123\n",
      "step = 2900: Average reward = 0.03004\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  6%|▌         | 3007/50000 [01:01<15:16, 51.28it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 3000: loss = 0.5059511661529541\n",
      "step = 3000: Average reward = 0.03004\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  6%|▌         | 3105/50000 [01:03<17:23, 44.95it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 3100: loss = 0.4568004608154297\n",
      "step = 3100: Average reward = 0.03004\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  6%|▋         | 3207/50000 [01:05<15:29, 50.32it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 3200: loss = 0.6708369851112366\n",
      "step = 3200: Average reward = 0.03004\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  7%|▋         | 3310/50000 [01:07<14:35, 53.33it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 3300: loss = 0.5430657863616943\n",
      "step = 3300: Average reward = 0.03004\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  7%|▋         | 3406/50000 [01:09<15:48, 49.12it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 3400: loss = 0.517945408821106\n",
      "step = 3400: Average reward = 0.67443\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  7%|▋         | 3506/50000 [01:11<15:37, 49.61it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 3500: loss = 0.4151574969291687\n",
      "step = 3500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  7%|▋         | 3607/50000 [01:13<16:09, 47.87it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 3600: loss = 0.3525448441505432\n",
      "step = 3600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  7%|▋         | 3705/50000 [01:15<14:29, 53.25it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 3700: loss = 0.3561805188655853\n",
      "step = 3700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  8%|▊         | 3806/50000 [01:17<17:23, 44.28it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 3800: loss = 0.40339064598083496\n",
      "step = 3800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  8%|▊         | 3908/50000 [01:19<14:41, 52.30it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 3900: loss = 0.45510104298591614\n",
      "step = 3900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  8%|▊         | 4010/50000 [01:21<14:50, 51.63it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 4000: loss = 0.32883745431900024\n",
      "step = 4000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  8%|▊         | 4106/50000 [01:23<17:11, 44.48it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 4100: loss = 0.5365874767303467\n",
      "step = 4100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  8%|▊         | 4203/50000 [01:25<16:00, 47.68it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 4200: loss = 0.424064040184021\n",
      "step = 4200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  9%|▊         | 4310/50000 [01:27<14:08, 53.87it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 4300: loss = 0.4470706582069397\n",
      "step = 4300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  9%|▉         | 4410/50000 [01:29<16:09, 47.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 4400: loss = 0.33087486028671265\n",
      "step = 4400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  9%|▉         | 4509/50000 [01:31<14:36, 51.89it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 4500: loss = 0.36544227600097656\n",
      "step = 4500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  9%|▉         | 4609/50000 [01:34<15:25, 49.03it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 4600: loss = 0.4072091579437256\n",
      "step = 4600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  9%|▉         | 4708/50000 [01:36<15:59, 47.20it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 4700: loss = 0.32193461060523987\n",
      "step = 4700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|▉         | 4806/50000 [01:38<15:24, 48.89it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 4800: loss = 0.4477141499519348\n",
      "step = 4800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|▉         | 4908/50000 [01:39<14:18, 52.51it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 4900: loss = 0.34200453758239746\n",
      "step = 4900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|█         | 5008/50000 [01:42<15:02, 49.85it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 5000: loss = 0.3147464990615845\n",
      "step = 5000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|█         | 5105/50000 [01:44<15:13, 49.17it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 5100: loss = 0.3240787088871002\n",
      "step = 5100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|█         | 5209/50000 [01:45<14:34, 51.23it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 5200: loss = 0.30754613876342773\n",
      "step = 5200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 11%|█         | 5305/50000 [01:47<15:05, 49.38it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 5300: loss = 0.3294426202774048\n",
      "step = 5300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 11%|█         | 5407/50000 [01:49<13:33, 54.85it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 5400: loss = 0.28132015466690063\n",
      "step = 5400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 11%|█         | 5505/50000 [01:51<13:57, 53.10it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 5500: loss = 0.2255890965461731\n",
      "step = 5500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 11%|█         | 5604/50000 [01:53<14:30, 50.99it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 5600: loss = 0.2321491539478302\n",
      "step = 5600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 11%|█▏        | 5705/50000 [01:55<13:08, 56.17it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 5700: loss = 0.28272077441215515\n",
      "step = 5700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 12%|█▏        | 5808/50000 [01:57<14:17, 51.56it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 5800: loss = 0.28822195529937744\n",
      "step = 5800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 12%|█▏        | 5909/50000 [01:59<14:21, 51.19it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 5900: loss = 0.2609707713127136\n",
      "step = 5900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 12%|█▏        | 6007/50000 [02:01<13:26, 54.53it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 6000: loss = 0.36865001916885376\n",
      "step = 6000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 12%|█▏        | 6108/50000 [02:03<14:08, 51.72it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 6100: loss = 0.25265172123908997\n",
      "step = 6100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 12%|█▏        | 6208/50000 [02:05<13:33, 53.81it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 6200: loss = 0.35842642188072205\n",
      "step = 6200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 13%|█▎        | 6308/50000 [02:07<14:46, 49.31it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 6300: loss = 0.3032422661781311\n",
      "step = 6300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 13%|█▎        | 6408/50000 [02:09<14:34, 49.86it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 6400: loss = 0.2494562566280365\n",
      "step = 6400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 13%|█▎        | 6510/50000 [02:11<13:35, 53.31it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 6500: loss = 0.2535061240196228\n",
      "step = 6500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 13%|█▎        | 6606/50000 [02:13<13:22, 54.08it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 6600: loss = 0.23273926973342896\n",
      "step = 6600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 13%|█▎        | 6707/50000 [02:15<14:18, 50.44it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 6700: loss = 0.2814701795578003\n",
      "step = 6700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 14%|█▎        | 6805/50000 [02:17<13:25, 53.61it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 6800: loss = 0.27493059635162354\n",
      "step = 6800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 14%|█▍        | 6905/50000 [02:19<13:07, 54.75it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 6900: loss = 0.2913702726364136\n",
      "step = 6900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 14%|█▍        | 7006/50000 [02:21<15:35, 45.96it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 7000: loss = 0.19538083672523499\n",
      "step = 7000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 14%|█▍        | 7109/50000 [02:23<13:32, 52.82it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 7100: loss = 0.26440444588661194\n",
      "step = 7100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 14%|█▍        | 7211/50000 [02:25<13:10, 54.16it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 7200: loss = 0.2743604779243469\n",
      "step = 7200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|█▍        | 7305/50000 [02:27<13:15, 53.66it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 7300: loss = 0.28517889976501465\n",
      "step = 7300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|█▍        | 7407/50000 [02:29<13:13, 53.70it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 7400: loss = 0.253776878118515\n",
      "step = 7400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|█▌        | 7511/50000 [02:31<12:56, 54.74it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 7500: loss = 0.3240359425544739\n",
      "step = 7500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|█▌        | 7608/50000 [02:33<14:29, 48.78it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 7600: loss = 0.27151352167129517\n",
      "step = 7600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|█▌        | 7706/50000 [02:35<15:32, 45.37it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 7700: loss = 0.3514629006385803\n",
      "step = 7700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 16%|█▌        | 7809/50000 [02:37<14:53, 47.25it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 7800: loss = 0.22813241183757782\n",
      "step = 7800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 16%|█▌        | 7906/50000 [02:39<13:23, 52.41it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 7900: loss = 0.26652052998542786\n",
      "step = 7900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 16%|█▌        | 8008/50000 [02:41<13:15, 52.81it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 8000: loss = 0.19098590314388275\n",
      "step = 8000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 16%|█▌        | 8104/50000 [02:43<13:44, 50.80it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 8100: loss = 0.18954959511756897\n",
      "step = 8100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 16%|█▋        | 8207/50000 [02:45<13:54, 50.05it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 8200: loss = 0.3359953463077545\n",
      "step = 8200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 17%|█▋        | 8306/50000 [02:47<12:43, 54.58it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 8300: loss = 0.38436105847358704\n",
      "step = 8300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 17%|█▋        | 8408/50000 [02:49<13:09, 52.67it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 8400: loss = 0.2658933401107788\n",
      "step = 8400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 17%|█▋        | 8509/50000 [02:50<12:26, 55.54it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 8500: loss = 0.20410332083702087\n",
      "step = 8500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 17%|█▋        | 8605/50000 [02:52<12:56, 53.30it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 8600: loss = 0.32415077090263367\n",
      "step = 8600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 17%|█▋        | 8705/50000 [02:54<14:30, 47.45it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 8700: loss = 0.35799354314804077\n",
      "step = 8700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 18%|█▊        | 8806/50000 [02:56<12:34, 54.59it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 8800: loss = 0.24831153452396393\n",
      "step = 8800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 18%|█▊        | 8907/50000 [02:58<13:49, 49.53it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 8900: loss = 0.18878595530986786\n",
      "step = 8900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 18%|█▊        | 9008/50000 [03:00<13:05, 52.15it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 9000: loss = 0.2639472186565399\n",
      "step = 9000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 18%|█▊        | 9108/50000 [03:03<12:40, 53.74it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 9100: loss = 0.25487565994262695\n",
      "step = 9100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 18%|█▊        | 9208/50000 [03:04<12:59, 52.32it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 9200: loss = 0.2637191712856293\n",
      "step = 9200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 19%|█▊        | 9307/50000 [03:06<13:00, 52.11it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 9300: loss = 0.252956748008728\n",
      "step = 9300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 19%|█▉        | 9408/50000 [03:08<13:08, 51.45it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 9400: loss = 0.16302545368671417\n",
      "step = 9400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 19%|█▉        | 9509/50000 [03:10<14:26, 46.71it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 9500: loss = 0.2881779074668884\n",
      "step = 9500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 19%|█▉        | 9606/50000 [03:12<12:59, 51.79it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 9600: loss = 0.2931191027164459\n",
      "step = 9600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 19%|█▉        | 9706/50000 [03:14<12:22, 54.30it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 9700: loss = 0.2585594058036804\n",
      "step = 9700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|█▉        | 9805/50000 [03:17<15:54, 42.10it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 9800: loss = 0.2923431098461151\n",
      "step = 9800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|█▉        | 9907/50000 [03:18<11:47, 56.65it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 9900: loss = 0.2402253895998001\n",
      "step = 9900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|██        | 10008/50000 [03:21<13:02, 51.13it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 10000: loss = 0.2778225243091583\n",
      "step = 10000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|██        | 10110/50000 [03:23<12:14, 54.28it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 10100: loss = 0.27500995993614197\n",
      "step = 10100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|██        | 10206/50000 [03:24<12:29, 53.11it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 10200: loss = 0.29587799310684204\n",
      "step = 10200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 21%|██        | 10308/50000 [03:26<13:38, 48.47it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 10300: loss = 0.24167881906032562\n",
      "step = 10300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 21%|██        | 10409/50000 [03:28<12:54, 51.09it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 10400: loss = 0.28341931104660034\n",
      "step = 10400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 21%|██        | 10506/50000 [03:30<13:38, 48.23it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 10500: loss = 0.1992153376340866\n",
      "step = 10500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 21%|██        | 10607/50000 [03:32<13:07, 50.03it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 10600: loss = 0.21505674719810486\n",
      "step = 10600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 21%|██▏       | 10709/50000 [03:34<14:15, 45.94it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 10700: loss = 0.23667404055595398\n",
      "step = 10700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 22%|██▏       | 10807/50000 [03:36<12:04, 54.09it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 10800: loss = 0.22405646741390228\n",
      "step = 10800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 22%|██▏       | 10909/50000 [03:38<12:11, 53.43it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 10900: loss = 0.22211170196533203\n",
      "step = 10900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 22%|██▏       | 11011/50000 [03:40<11:53, 54.67it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 11000: loss = 0.20888805389404297\n",
      "step = 11000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 22%|██▏       | 11107/50000 [03:42<12:30, 51.85it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 11100: loss = 0.22969283163547516\n",
      "step = 11100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 22%|██▏       | 11206/50000 [03:44<12:16, 52.66it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 11200: loss = 0.166306734085083\n",
      "step = 11200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 23%|██▎       | 11306/50000 [03:46<11:41, 55.18it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 11300: loss = 0.19000059366226196\n",
      "step = 11300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 23%|██▎       | 11405/50000 [03:48<13:26, 47.88it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 11400: loss = 0.2080598920583725\n",
      "step = 11400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 23%|██▎       | 11507/50000 [03:50<12:26, 51.55it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 11500: loss = 0.2134280651807785\n",
      "step = 11500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 23%|██▎       | 11609/50000 [03:52<12:29, 51.21it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 11600: loss = 0.1978999674320221\n",
      "step = 11600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 23%|██▎       | 11711/50000 [03:54<12:12, 52.28it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 11700: loss = 0.1885223388671875\n",
      "step = 11700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 24%|██▎       | 11807/50000 [03:56<12:43, 50.03it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 11800: loss = 0.16926126182079315\n",
      "step = 11800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 24%|██▍       | 11906/50000 [03:58<13:01, 48.74it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 11900: loss = 0.18933871388435364\n",
      "step = 11900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 24%|██▍       | 12008/50000 [04:00<11:55, 53.08it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 12000: loss = 0.20241481065750122\n",
      "step = 12000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 24%|██▍       | 12107/50000 [04:02<11:49, 53.38it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 12100: loss = 0.18192586302757263\n",
      "step = 12100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 24%|██▍       | 12209/50000 [04:04<12:17, 51.26it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 12200: loss = 0.2384447455406189\n",
      "step = 12200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|██▍       | 12308/50000 [04:06<12:44, 49.28it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 12300: loss = 0.2652911841869354\n",
      "step = 12300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|██▍       | 12404/50000 [04:08<12:16, 51.08it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 12400: loss = 0.22804459929466248\n",
      "step = 12400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|██▌       | 12511/50000 [04:10<11:27, 54.57it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 12500: loss = 0.1873779594898224\n",
      "step = 12500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|██▌       | 12610/50000 [04:12<11:36, 53.67it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 12600: loss = 0.33263278007507324\n",
      "step = 12600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|██▌       | 12709/50000 [04:14<11:10, 55.66it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 12700: loss = 0.11429652571678162\n",
      "step = 12700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 26%|██▌       | 12805/50000 [04:16<13:15, 46.73it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 12800: loss = 0.27201879024505615\n",
      "step = 12800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 26%|██▌       | 12910/50000 [04:18<11:39, 53.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 12900: loss = 0.20494729280471802\n",
      "step = 12900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 26%|██▌       | 13006/50000 [04:19<12:14, 50.38it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 13000: loss = 0.28290659189224243\n",
      "step = 13000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 26%|██▌       | 13106/50000 [04:21<12:49, 47.96it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 13100: loss = 0.14467181265354156\n",
      "step = 13100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 26%|██▋       | 13206/50000 [04:23<12:00, 51.04it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 13200: loss = 0.2608652412891388\n",
      "step = 13200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 27%|██▋       | 13305/50000 [04:25<12:10, 50.24it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 13300: loss = 0.22825229167938232\n",
      "step = 13300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 27%|██▋       | 13409/50000 [04:28<12:16, 49.69it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 13400: loss = 0.2361580729484558\n",
      "step = 13400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 27%|██▋       | 13506/50000 [04:29<11:37, 52.36it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 13500: loss = 0.22661563754081726\n",
      "step = 13500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 27%|██▋       | 13609/50000 [04:32<12:43, 47.64it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 13600: loss = 0.24139735102653503\n",
      "step = 13600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 27%|██▋       | 13709/50000 [04:34<12:10, 49.69it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 13700: loss = 0.20358385145664215\n",
      "step = 13700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 28%|██▊       | 13806/50000 [04:36<13:11, 45.75it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 13800: loss = 0.30916500091552734\n",
      "step = 13800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 28%|██▊       | 13910/50000 [04:38<11:52, 50.68it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 13900: loss = 0.1579853892326355\n",
      "step = 13900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 28%|██▊       | 14005/50000 [04:40<12:06, 49.52it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 14000: loss = 0.23517484962940216\n",
      "step = 14000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 28%|██▊       | 14106/50000 [04:42<11:51, 50.46it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 14100: loss = 0.21258842945098877\n",
      "step = 14100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 28%|██▊       | 14206/50000 [04:44<12:19, 48.41it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 14200: loss = 0.2310241460800171\n",
      "step = 14200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 29%|██▊       | 14305/50000 [04:46<11:40, 50.95it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 14300: loss = 0.16820469498634338\n",
      "step = 14300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 29%|██▉       | 14408/50000 [04:48<11:13, 52.84it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 14400: loss = 0.1614874303340912\n",
      "step = 14400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 29%|██▉       | 14509/50000 [04:50<11:48, 50.13it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 14500: loss = 0.15779735147953033\n",
      "step = 14500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 29%|██▉       | 14605/50000 [04:52<12:39, 46.60it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 14600: loss = 0.18468257784843445\n",
      "step = 14600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 29%|██▉       | 14709/50000 [04:54<12:33, 46.82it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 14700: loss = 0.21008408069610596\n",
      "step = 14700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|██▉       | 14806/50000 [04:56<11:21, 51.64it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 14800: loss = 0.206612229347229\n",
      "step = 14800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|██▉       | 14905/50000 [04:58<13:09, 44.43it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 14900: loss = 0.278861403465271\n",
      "step = 14900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|███       | 15006/50000 [05:00<10:52, 53.65it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 15000: loss = 0.15785491466522217\n",
      "step = 15000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|███       | 15108/50000 [05:02<11:22, 51.14it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 15100: loss = 0.2055061161518097\n",
      "step = 15100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|███       | 15210/50000 [05:04<10:28, 55.31it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 15200: loss = 0.15053439140319824\n",
      "step = 15200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 31%|███       | 15309/50000 [05:06<12:15, 47.14it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 15300: loss = 0.2078336626291275\n",
      "step = 15300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 31%|███       | 15409/50000 [05:08<11:01, 52.30it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 15400: loss = 0.16929857432842255\n",
      "step = 15400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 31%|███       | 15506/50000 [05:10<11:44, 48.96it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 15500: loss = 0.1675766408443451\n",
      "step = 15500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 31%|███       | 15608/50000 [05:12<11:31, 49.77it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 15600: loss = 0.2128806710243225\n",
      "step = 15600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 31%|███▏      | 15708/50000 [05:14<11:11, 51.04it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 15700: loss = 0.1880221962928772\n",
      "step = 15700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 32%|███▏      | 15805/50000 [05:16<10:53, 52.33it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 15800: loss = 0.16214418411254883\n",
      "step = 15800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 32%|███▏      | 15907/50000 [05:18<11:40, 48.70it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 15900: loss = 0.2679818272590637\n",
      "step = 15900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 32%|███▏      | 16005/50000 [05:20<10:52, 52.10it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 16000: loss = 0.17388379573822021\n",
      "step = 16000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 32%|███▏      | 16107/50000 [05:22<11:41, 48.31it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 16100: loss = 0.1997818797826767\n",
      "step = 16100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 32%|███▏      | 16209/50000 [05:24<10:15, 54.90it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 16200: loss = 0.19260656833648682\n",
      "step = 16200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 33%|███▎      | 16305/50000 [05:25<11:02, 50.88it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 16300: loss = 0.2811053395271301\n",
      "step = 16300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 33%|███▎      | 16407/50000 [05:27<11:08, 50.25it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 16400: loss = 0.15236777067184448\n",
      "step = 16400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 33%|███▎      | 16509/50000 [05:30<11:05, 50.33it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 16500: loss = 0.15942668914794922\n",
      "step = 16500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 33%|███▎      | 16605/50000 [05:31<10:25, 53.39it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 16600: loss = 0.19230148196220398\n",
      "step = 16600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 33%|███▎      | 16707/50000 [05:33<10:18, 53.82it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 16700: loss = 0.14781004190444946\n",
      "step = 16700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 34%|███▎      | 16805/50000 [05:35<11:33, 47.83it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 16800: loss = 0.18730944395065308\n",
      "step = 16800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 34%|███▍      | 16905/50000 [05:37<10:49, 50.94it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 16900: loss = 0.2027626633644104\n",
      "step = 16900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 34%|███▍      | 17005/50000 [05:39<11:35, 47.45it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 17000: loss = 0.13337726891040802\n",
      "step = 17000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 34%|███▍      | 17107/50000 [05:41<10:24, 52.70it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 17100: loss = 0.25089403986930847\n",
      "step = 17100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 34%|███▍      | 17209/50000 [05:43<10:45, 50.80it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 17200: loss = 0.1981656402349472\n",
      "step = 17200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|███▍      | 17304/50000 [05:45<10:47, 50.49it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 17300: loss = 0.2109333574771881\n",
      "step = 17300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|███▍      | 17410/50000 [05:47<10:11, 53.33it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 17400: loss = 0.17682212591171265\n",
      "step = 17400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|███▌      | 17509/50000 [05:49<11:09, 48.56it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 17500: loss = 0.12616288661956787\n",
      "step = 17500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|███▌      | 17609/50000 [05:51<09:34, 56.37it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 17600: loss = 0.21361488103866577\n",
      "step = 17600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|███▌      | 17706/50000 [05:53<10:50, 49.64it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 17700: loss = 0.12867702543735504\n",
      "step = 17700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 36%|███▌      | 17810/50000 [05:55<09:56, 53.92it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 17800: loss = 0.20047280192375183\n",
      "step = 17800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 36%|███▌      | 17906/50000 [05:57<10:05, 52.97it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 17900: loss = 0.19100633263587952\n",
      "step = 17900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 36%|███▌      | 18006/50000 [05:59<10:23, 51.29it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 18000: loss = 0.16534680128097534\n",
      "step = 18000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 36%|███▌      | 18108/50000 [06:01<10:00, 53.11it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 18100: loss = 0.1429644227027893\n",
      "step = 18100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 36%|███▋      | 18209/50000 [06:03<10:00, 52.95it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 18200: loss = 0.12241768091917038\n",
      "step = 18200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 37%|███▋      | 18309/50000 [06:05<10:08, 52.07it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 18300: loss = 0.1242869570851326\n",
      "step = 18300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 37%|███▋      | 18408/50000 [06:07<10:32, 49.93it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 18400: loss = 0.2277151495218277\n",
      "step = 18400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 37%|███▋      | 18506/50000 [06:09<10:02, 52.24it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 18500: loss = 0.1778530776500702\n",
      "step = 18500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 37%|███▋      | 18608/50000 [06:11<10:26, 50.07it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 18600: loss = 0.1449587643146515\n",
      "step = 18600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 37%|███▋      | 18709/50000 [06:13<09:57, 52.39it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 18700: loss = 0.12202013283967972\n",
      "step = 18700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 38%|███▊      | 18805/50000 [06:15<10:05, 51.51it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 18800: loss = 0.19640855491161346\n",
      "step = 18800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 38%|███▊      | 18909/50000 [06:17<10:03, 51.48it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 18900: loss = 0.16588455438613892\n",
      "step = 18900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 38%|███▊      | 19007/50000 [06:19<10:54, 47.38it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 19000: loss = 0.1251099556684494\n",
      "step = 19000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 38%|███▊      | 19107/50000 [06:21<09:56, 51.78it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 19100: loss = 0.18406343460083008\n",
      "step = 19100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 38%|███▊      | 19209/50000 [06:23<09:17, 55.27it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 19200: loss = 0.15673846006393433\n",
      "step = 19200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 39%|███▊      | 19310/50000 [06:25<10:04, 50.77it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 19300: loss = 0.21109330654144287\n",
      "step = 19300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 39%|███▉      | 19409/50000 [06:27<10:49, 47.13it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 19400: loss = 0.16153103113174438\n",
      "step = 19400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 39%|███▉      | 19509/50000 [06:28<09:22, 54.24it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 19500: loss = 0.13216957449913025\n",
      "step = 19500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 39%|███▉      | 19604/50000 [06:30<10:14, 49.48it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 19600: loss = 0.10276581346988678\n",
      "step = 19600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 39%|███▉      | 19711/50000 [06:33<09:42, 51.98it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 19700: loss = 0.15009509027004242\n",
      "step = 19700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|███▉      | 19809/50000 [06:35<10:19, 48.73it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 19800: loss = 0.11135133355855942\n",
      "step = 19800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|███▉      | 19910/50000 [06:37<10:16, 48.83it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 19900: loss = 0.1337921917438507\n",
      "step = 19900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████      | 20008/50000 [06:38<09:48, 50.94it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: loss = 0.1667024791240692\n",
      "step = 20000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████      | 20108/50000 [06:40<09:56, 50.08it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20100: loss = 0.10984188318252563\n",
      "step = 20100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████      | 20210/50000 [06:42<09:44, 50.98it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20200: loss = 0.20240941643714905\n",
      "step = 20200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 41%|████      | 20306/50000 [06:44<10:04, 49.09it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20300: loss = 0.06572867929935455\n",
      "step = 20300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 41%|████      | 20405/50000 [06:46<10:04, 48.94it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20400: loss = 0.10437092185020447\n",
      "step = 20400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 41%|████      | 20509/50000 [06:48<09:40, 50.81it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20500: loss = 0.11493844538927078\n",
      "step = 20500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 41%|████      | 20606/50000 [06:50<10:48, 45.31it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20600: loss = 0.20522817969322205\n",
      "step = 20600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 41%|████▏     | 20709/50000 [06:52<09:59, 48.84it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20700: loss = 0.13036653399467468\n",
      "step = 20700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 42%|████▏     | 20810/50000 [06:54<09:50, 49.42it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20800: loss = 0.18533042073249817\n",
      "step = 20800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 42%|████▏     | 20906/50000 [06:56<08:48, 55.05it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20900: loss = 0.1236574724316597\n",
      "step = 20900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 42%|████▏     | 21008/50000 [06:58<08:43, 55.34it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 21000: loss = 0.15733566880226135\n",
      "step = 21000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 42%|████▏     | 21105/50000 [07:00<10:38, 45.27it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 21100: loss = 0.18770691752433777\n",
      "step = 21100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 42%|████▏     | 21206/50000 [07:02<09:38, 49.76it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 21200: loss = 0.15279266238212585\n",
      "step = 21200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 43%|████▎     | 21302/50000 [07:04<09:15, 51.62it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 21300: loss = 0.1733396351337433\n",
      "step = 21300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 43%|████▎     | 21406/50000 [07:06<09:42, 49.08it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 21400: loss = 0.14436578750610352\n",
      "step = 21400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 43%|████▎     | 21507/50000 [07:08<09:07, 52.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 21500: loss = 0.16919437050819397\n",
      "step = 21500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 43%|████▎     | 21609/50000 [07:10<10:02, 47.11it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 21600: loss = 0.13450351357460022\n",
      "step = 21600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 43%|████▎     | 21705/50000 [07:12<08:58, 52.52it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 21700: loss = 0.15024559199810028\n",
      "step = 21700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 44%|████▎     | 21808/50000 [07:14<09:23, 50.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 21800: loss = 0.14221222698688507\n",
      "step = 21800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 44%|████▍     | 21908/50000 [07:16<09:17, 50.35it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 21900: loss = 0.11959229409694672\n",
      "step = 21900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 44%|████▍     | 22009/50000 [07:18<09:16, 50.33it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 22000: loss = 0.13983193039894104\n",
      "step = 22000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 44%|████▍     | 22111/50000 [07:21<08:41, 53.49it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 22100: loss = 0.13636431097984314\n",
      "step = 22100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 44%|████▍     | 22205/50000 [07:22<08:43, 53.11it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 22200: loss = 0.14659062027931213\n",
      "step = 22200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████▍     | 22308/50000 [07:24<08:31, 54.17it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 22300: loss = 0.23070162534713745\n",
      "step = 22300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████▍     | 22409/50000 [07:26<08:53, 51.75it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 22400: loss = 0.08482587337493896\n",
      "step = 22400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████▌     | 22507/50000 [07:28<10:03, 45.54it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 22500: loss = 0.17746610939502716\n",
      "step = 22500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████▌     | 22607/50000 [07:30<08:41, 52.50it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 22600: loss = 0.16854220628738403\n",
      "step = 22600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████▌     | 22708/50000 [07:32<08:40, 52.39it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 22700: loss = 0.2297433614730835\n",
      "step = 22700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 46%|████▌     | 22807/50000 [07:35<09:47, 46.29it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 22800: loss = 0.19169998168945312\n",
      "step = 22800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 46%|████▌     | 22907/50000 [07:37<09:25, 47.88it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 22900: loss = 0.1711195409297943\n",
      "step = 22900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 46%|████▌     | 23004/50000 [07:38<07:54, 56.84it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 23000: loss = 0.10997170209884644\n",
      "step = 23000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 46%|████▌     | 23106/50000 [07:40<08:14, 54.35it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 23100: loss = 0.15172016620635986\n",
      "step = 23100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 46%|████▋     | 23206/50000 [07:42<08:55, 49.99it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 23200: loss = 0.15038925409317017\n",
      "step = 23200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 47%|████▋     | 23303/50000 [07:44<08:39, 51.38it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 23300: loss = 0.12794466316699982\n",
      "step = 23300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 47%|████▋     | 23408/50000 [07:47<08:52, 49.92it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 23400: loss = 0.13094131648540497\n",
      "step = 23400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 47%|████▋     | 23508/50000 [07:49<08:25, 52.38it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 23500: loss = 0.1515105962753296\n",
      "step = 23500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 47%|████▋     | 23606/50000 [07:51<09:01, 48.71it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 23600: loss = 0.18966342508792877\n",
      "step = 23600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 47%|████▋     | 23705/50000 [07:53<08:47, 49.88it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 23700: loss = 0.06892657279968262\n",
      "step = 23700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 48%|████▊     | 23807/50000 [07:54<08:08, 53.63it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 23800: loss = 0.17228558659553528\n",
      "step = 23800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 48%|████▊     | 23906/50000 [07:57<08:39, 50.18it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 23900: loss = 0.18388047814369202\n",
      "step = 23900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 48%|████▊     | 24007/50000 [07:59<08:27, 51.19it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 24000: loss = 0.10597456246614456\n",
      "step = 24000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 48%|████▊     | 24107/50000 [08:01<08:35, 50.19it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 24100: loss = 0.13009405136108398\n",
      "step = 24100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 48%|████▊     | 24205/50000 [08:03<09:17, 46.27it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 24200: loss = 0.10546504706144333\n",
      "step = 24200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 49%|████▊     | 24309/50000 [08:05<08:12, 52.18it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 24300: loss = 0.08668354153633118\n",
      "step = 24300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 49%|████▉     | 24411/50000 [08:07<08:10, 52.17it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 24400: loss = 0.1373712420463562\n",
      "step = 24400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 49%|████▉     | 24506/50000 [08:08<07:22, 57.61it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 24500: loss = 0.0932241827249527\n",
      "step = 24500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 49%|████▉     | 24608/50000 [08:10<08:24, 50.30it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 24600: loss = 0.19980959594249725\n",
      "step = 24600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 49%|████▉     | 24709/50000 [08:12<08:29, 49.62it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 24700: loss = 0.13656441867351532\n",
      "step = 24700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████▉     | 24805/50000 [08:15<12:10, 34.48it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 24800: loss = 0.1137770414352417\n",
      "step = 24800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████▉     | 24911/50000 [08:19<08:38, 48.42it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 24900: loss = 0.12638820707798004\n",
      "step = 24900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|█████     | 25011/50000 [08:21<07:43, 53.91it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 25000: loss = 0.09046854078769684\n",
      "step = 25000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|█████     | 25105/50000 [08:23<08:25, 49.27it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 25100: loss = 0.20177611708641052\n",
      "step = 25100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|█████     | 25207/50000 [08:25<08:10, 50.55it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 25200: loss = 0.18870201706886292\n",
      "step = 25200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 51%|█████     | 25311/50000 [08:27<06:59, 58.89it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 25300: loss = 0.18225866556167603\n",
      "step = 25300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 51%|█████     | 25406/50000 [08:28<07:46, 52.72it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 25400: loss = 0.13415203988552094\n",
      "step = 25400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 51%|█████     | 25507/50000 [08:30<07:42, 53.00it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 25500: loss = 0.1423225998878479\n",
      "step = 25500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 51%|█████     | 25605/50000 [08:32<08:47, 46.25it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 25600: loss = 0.16660791635513306\n",
      "step = 25600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 51%|█████▏    | 25710/50000 [08:34<08:13, 49.18it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 25700: loss = 0.20772401988506317\n",
      "step = 25700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 52%|█████▏    | 25806/50000 [08:36<07:22, 54.68it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 25800: loss = 0.14142678678035736\n",
      "step = 25800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 52%|█████▏    | 25908/50000 [08:38<07:50, 51.22it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 25900: loss = 0.15115728974342346\n",
      "step = 25900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 52%|█████▏    | 26009/50000 [08:40<07:11, 55.64it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 26000: loss = 0.14541611075401306\n",
      "step = 26000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 52%|█████▏    | 26109/50000 [08:42<07:47, 51.10it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 26100: loss = 0.11902819573879242\n",
      "step = 26100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 52%|█████▏    | 26205/50000 [08:44<07:47, 50.93it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 26200: loss = 0.09817615896463394\n",
      "step = 26200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 53%|█████▎    | 26307/50000 [08:46<07:23, 53.39it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 26300: loss = 0.12134581804275513\n",
      "step = 26300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 53%|█████▎    | 26409/50000 [08:48<07:57, 49.38it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 26400: loss = 0.13206931948661804\n",
      "step = 26400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 53%|█████▎    | 26509/50000 [08:50<07:56, 49.32it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 26500: loss = 0.10916297882795334\n",
      "step = 26500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 53%|█████▎    | 26611/50000 [08:52<06:54, 56.38it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 26600: loss = 0.09637342393398285\n",
      "step = 26600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 53%|█████▎    | 26706/50000 [08:54<07:04, 54.87it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 26700: loss = 0.1594517081975937\n",
      "step = 26700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 54%|█████▎    | 26808/50000 [08:56<07:05, 54.53it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 26800: loss = 0.08122963458299637\n",
      "step = 26800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 54%|█████▍    | 26907/50000 [08:58<07:16, 52.89it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 26900: loss = 0.11879269033670425\n",
      "step = 26900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 54%|█████▍    | 27009/50000 [09:00<07:09, 53.50it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 27000: loss = 0.09693773090839386\n",
      "step = 27000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 54%|█████▍    | 27105/50000 [09:02<07:04, 53.95it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 27100: loss = 0.10772758722305298\n",
      "step = 27100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 54%|█████▍    | 27206/50000 [09:04<07:17, 52.13it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 27200: loss = 0.09299974143505096\n",
      "step = 27200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|█████▍    | 27307/50000 [09:06<07:47, 48.52it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 27300: loss = 0.14595511555671692\n",
      "step = 27300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|█████▍    | 27407/50000 [09:08<07:30, 50.16it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 27400: loss = 0.203144833445549\n",
      "step = 27400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|█████▌    | 27509/50000 [09:10<07:58, 46.99it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 27500: loss = 0.06307527422904968\n",
      "step = 27500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|█████▌    | 27605/50000 [09:11<07:42, 48.42it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 27600: loss = 0.15449342131614685\n",
      "step = 27600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|█████▌    | 27705/50000 [09:14<07:55, 46.89it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 27700: loss = 0.11999814957380295\n",
      "step = 27700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 56%|█████▌    | 27807/50000 [09:16<07:08, 51.75it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 27800: loss = 0.10355889797210693\n",
      "step = 27800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 56%|█████▌    | 27910/50000 [09:18<06:37, 55.56it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 27900: loss = 0.10375884920358658\n",
      "step = 27900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 56%|█████▌    | 28006/50000 [09:19<06:59, 52.43it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 28000: loss = 0.13684362173080444\n",
      "step = 28000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 56%|█████▌    | 28106/50000 [09:21<07:18, 49.88it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 28100: loss = 0.13668939471244812\n",
      "step = 28100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 56%|█████▋    | 28208/50000 [09:23<07:12, 50.36it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 28200: loss = 0.11182953417301178\n",
      "step = 28200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 57%|█████▋    | 28310/50000 [09:25<07:02, 51.37it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 28300: loss = 0.08045421540737152\n",
      "step = 28300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 57%|█████▋    | 28408/50000 [09:28<07:47, 46.20it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 28400: loss = 0.1502358615398407\n",
      "step = 28400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 57%|█████▋    | 28505/50000 [09:29<07:36, 47.11it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 28500: loss = 0.09586245566606522\n",
      "step = 28500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 57%|█████▋    | 28610/50000 [09:32<07:28, 47.68it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 28600: loss = 0.15911604464054108\n",
      "step = 28600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 57%|█████▋    | 28706/50000 [09:34<07:41, 46.17it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 28700: loss = 0.09909418225288391\n",
      "step = 28700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 58%|█████▊    | 28807/50000 [09:36<06:28, 54.48it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 28800: loss = 0.16240675747394562\n",
      "step = 28800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 58%|█████▊    | 28908/50000 [09:38<07:32, 46.62it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 28900: loss = 0.0540677085518837\n",
      "step = 28900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 58%|█████▊    | 29008/50000 [09:40<06:39, 52.51it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 29000: loss = 0.13401253521442413\n",
      "step = 29000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 58%|█████▊    | 29103/50000 [09:42<07:44, 44.95it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 29100: loss = 0.07708092033863068\n",
      "step = 29100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 58%|█████▊    | 29209/50000 [09:44<06:50, 50.71it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 29200: loss = 0.1587786227464676\n",
      "step = 29200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 59%|█████▊    | 29307/50000 [09:46<07:12, 47.80it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 29300: loss = 0.1578882336616516\n",
      "step = 29300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 59%|█████▉    | 29408/50000 [09:48<07:06, 48.27it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 29400: loss = 0.18199345469474792\n",
      "step = 29400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 59%|█████▉    | 29507/50000 [09:50<06:18, 54.17it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 29500: loss = 0.08256269246339798\n",
      "step = 29500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 59%|█████▉    | 29609/50000 [09:51<06:21, 53.51it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 29600: loss = 0.1326289176940918\n",
      "step = 29600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 59%|█████▉    | 29706/50000 [09:54<06:39, 50.79it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 29700: loss = 0.08721454441547394\n",
      "step = 29700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|█████▉    | 29808/50000 [09:56<07:30, 44.78it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 29800: loss = 0.09832629561424255\n",
      "step = 29800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|█████▉    | 29909/50000 [09:58<07:05, 47.20it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 29900: loss = 0.1264883577823639\n",
      "step = 29900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|██████    | 30008/50000 [10:00<06:27, 51.62it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 30000: loss = 0.08014947175979614\n",
      "step = 30000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|██████    | 30104/50000 [10:02<06:13, 53.25it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 30100: loss = 0.17642466723918915\n",
      "step = 30100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|██████    | 30208/50000 [10:04<07:12, 45.75it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 30200: loss = 0.15776529908180237\n",
      "step = 30200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 61%|██████    | 30306/50000 [10:06<06:39, 49.27it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 30300: loss = 0.07319218665361404\n",
      "step = 30300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 61%|██████    | 30411/50000 [10:08<05:59, 54.43it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 30400: loss = 0.10839751362800598\n",
      "step = 30400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 61%|██████    | 30507/50000 [10:10<05:41, 57.08it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 30500: loss = 0.11838110536336899\n",
      "step = 30500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 61%|██████    | 30609/50000 [10:11<05:56, 54.33it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 30600: loss = 0.073957160115242\n",
      "step = 30600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 61%|██████▏   | 30710/50000 [10:13<06:13, 51.69it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 30700: loss = 0.1268344521522522\n",
      "step = 30700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 62%|██████▏   | 30809/50000 [10:15<06:14, 51.20it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 30800: loss = 0.18344098329544067\n",
      "step = 30800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 62%|██████▏   | 30905/50000 [10:17<06:33, 48.50it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 30900: loss = 0.09878292679786682\n",
      "step = 30900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 62%|██████▏   | 31007/50000 [10:19<05:55, 53.45it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 31000: loss = 0.10482463240623474\n",
      "step = 31000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 62%|██████▏   | 31109/50000 [10:21<05:55, 53.18it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 31100: loss = 0.14232316613197327\n",
      "step = 31100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 62%|██████▏   | 31205/50000 [10:23<06:06, 51.23it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 31200: loss = 0.0754336565732956\n",
      "step = 31200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 63%|██████▎   | 31310/50000 [10:25<05:54, 52.70it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 31300: loss = 0.10718562453985214\n",
      "step = 31300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 63%|██████▎   | 31407/50000 [10:27<05:42, 54.29it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 31400: loss = 0.16271595656871796\n",
      "step = 31400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 63%|██████▎   | 31506/50000 [10:29<06:40, 46.21it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 31500: loss = 0.09936541318893433\n",
      "step = 31500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 63%|██████▎   | 31605/50000 [10:31<06:11, 49.47it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 31600: loss = 0.09392279386520386\n",
      "step = 31600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 63%|██████▎   | 31706/50000 [10:33<06:03, 50.30it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 31700: loss = 0.09751465916633606\n",
      "step = 31700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 64%|██████▎   | 31807/50000 [10:35<06:17, 48.19it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 31800: loss = 0.09575455635786057\n",
      "step = 31800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 64%|██████▍   | 31906/50000 [10:37<06:40, 45.19it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 31900: loss = 0.07906167954206467\n",
      "step = 31900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 64%|██████▍   | 32005/50000 [10:39<06:19, 47.45it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 32000: loss = 0.11198824644088745\n",
      "step = 32000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 64%|██████▍   | 32107/50000 [10:41<05:15, 56.67it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 32100: loss = 0.10354737937450409\n",
      "step = 32100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 64%|██████▍   | 32207/50000 [10:43<05:48, 51.12it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 32200: loss = 0.16865530610084534\n",
      "step = 32200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|██████▍   | 32305/50000 [10:45<05:46, 51.12it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 32300: loss = 0.07569520175457001\n",
      "step = 32300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|██████▍   | 32405/50000 [10:46<05:31, 53.05it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 32400: loss = 0.10035489499568939\n",
      "step = 32400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|██████▌   | 32508/50000 [10:48<05:36, 51.96it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 32500: loss = 0.14691027998924255\n",
      "step = 32500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|██████▌   | 32609/50000 [10:50<05:29, 52.86it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 32600: loss = 0.07855290919542313\n",
      "step = 32600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|██████▌   | 32706/50000 [10:52<06:21, 45.33it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 32700: loss = 0.1388520896434784\n",
      "step = 32700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 66%|██████▌   | 32805/50000 [10:54<05:09, 55.60it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 32800: loss = 0.09116393327713013\n",
      "step = 32800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 66%|██████▌   | 32905/50000 [10:56<05:39, 50.28it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 32900: loss = 0.15503905713558197\n",
      "step = 32900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 66%|██████▌   | 33006/50000 [10:58<05:32, 51.09it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 33000: loss = 0.1280408352613449\n",
      "step = 33000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 66%|██████▌   | 33108/50000 [11:00<05:08, 54.71it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 33100: loss = 0.09427307546138763\n",
      "step = 33100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 66%|██████▋   | 33210/50000 [11:02<05:11, 53.83it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 33200: loss = 0.12226726114749908\n",
      "step = 33200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 67%|██████▋   | 33305/50000 [11:04<05:45, 48.26it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 33300: loss = 0.07416464388370514\n",
      "step = 33300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 67%|██████▋   | 33409/50000 [11:06<05:39, 48.89it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 33400: loss = 0.11524844169616699\n",
      "step = 33400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 67%|██████▋   | 33507/50000 [11:08<05:31, 49.70it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 33500: loss = 0.07295465469360352\n",
      "step = 33500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 67%|██████▋   | 33609/50000 [11:10<04:55, 55.40it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 33600: loss = 0.06866112351417542\n",
      "step = 33600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 67%|██████▋   | 33705/50000 [11:12<05:16, 51.51it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 33700: loss = 0.1497071534395218\n",
      "step = 33700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 68%|██████▊   | 33806/50000 [11:14<05:10, 52.08it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 33800: loss = 0.07961468398571014\n",
      "step = 33800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 68%|██████▊   | 33905/50000 [11:16<05:30, 48.75it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 33900: loss = 0.10991096496582031\n",
      "step = 33900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 68%|██████▊   | 34006/50000 [11:18<05:16, 50.58it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 34000: loss = 0.11120528727769852\n",
      "step = 34000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 68%|██████▊   | 34108/50000 [11:20<05:37, 47.04it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 34100: loss = 0.04427584260702133\n",
      "step = 34100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 68%|██████▊   | 34207/50000 [11:22<05:06, 51.51it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 34200: loss = 0.06475342810153961\n",
      "step = 34200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 69%|██████▊   | 34309/50000 [11:24<05:17, 49.44it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 34300: loss = 0.14906446635723114\n",
      "step = 34300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 69%|██████▉   | 34407/50000 [11:26<05:09, 50.34it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 34400: loss = 0.19525787234306335\n",
      "step = 34400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 69%|██████▉   | 34508/50000 [11:28<04:48, 53.65it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 34500: loss = 0.11128270626068115\n",
      "step = 34500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 69%|██████▉   | 34610/50000 [11:30<05:10, 49.61it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 34600: loss = 0.14859704673290253\n",
      "step = 34600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 69%|██████▉   | 34706/50000 [11:32<04:51, 52.50it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 34700: loss = 0.07807154208421707\n",
      "step = 34700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|██████▉   | 34808/50000 [11:34<04:53, 51.82it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 34800: loss = 0.12480157613754272\n",
      "step = 34800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|██████▉   | 34910/50000 [11:36<04:42, 53.34it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 34900: loss = 0.11967307329177856\n",
      "step = 34900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|███████   | 35006/50000 [11:38<04:53, 51.16it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 35000: loss = 0.08061562478542328\n",
      "step = 35000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|███████   | 35108/50000 [11:39<04:38, 53.39it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 35100: loss = 0.09775638580322266\n",
      "step = 35100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|███████   | 35206/50000 [11:41<05:18, 46.46it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 35200: loss = 0.054789818823337555\n",
      "step = 35200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 71%|███████   | 35309/50000 [11:44<04:59, 49.05it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 35300: loss = 0.10850398987531662\n",
      "step = 35300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 71%|███████   | 35410/50000 [11:46<04:40, 52.10it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 35400: loss = 0.10090500861406326\n",
      "step = 35400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 71%|███████   | 35509/50000 [11:48<04:55, 48.96it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 35500: loss = 0.041846051812171936\n",
      "step = 35500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 71%|███████   | 35610/50000 [11:50<04:34, 52.44it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 35600: loss = 0.10371460020542145\n",
      "step = 35600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 71%|███████▏  | 35706/50000 [11:52<04:46, 49.95it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 35700: loss = 0.08989284932613373\n",
      "step = 35700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 72%|███████▏  | 35803/50000 [11:54<04:59, 47.36it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 35800: loss = 0.10974869132041931\n",
      "step = 35800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 72%|███████▏  | 35904/50000 [11:56<05:08, 45.67it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 35900: loss = 0.0902431309223175\n",
      "step = 35900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 72%|███████▏  | 36009/50000 [11:58<04:45, 49.04it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 36000: loss = 0.11812277138233185\n",
      "step = 36000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 72%|███████▏  | 36107/50000 [12:00<04:48, 48.11it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 36100: loss = 0.14154016971588135\n",
      "step = 36100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 72%|███████▏  | 36203/50000 [12:01<04:12, 54.61it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 36200: loss = 0.056368231773376465\n",
      "step = 36200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 73%|███████▎  | 36311/50000 [12:03<04:23, 51.93it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 36300: loss = 0.1301192194223404\n",
      "step = 36300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 73%|███████▎  | 36407/50000 [12:05<04:57, 45.74it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 36400: loss = 0.05454806983470917\n",
      "step = 36400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 73%|███████▎  | 36507/50000 [12:07<04:31, 49.77it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 36500: loss = 0.1724112331867218\n",
      "step = 36500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 73%|███████▎  | 36608/50000 [12:09<04:02, 55.21it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 36600: loss = 0.09005343914031982\n",
      "step = 36600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 73%|███████▎  | 36707/50000 [12:11<04:30, 49.08it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 36700: loss = 0.1167583093047142\n",
      "step = 36700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 74%|███████▎  | 36810/50000 [12:13<04:10, 52.66it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 36800: loss = 0.08893226087093353\n",
      "step = 36800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 74%|███████▍  | 36906/50000 [12:15<04:31, 48.29it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 36900: loss = 0.04173301160335541\n",
      "step = 36900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 74%|███████▍  | 37004/50000 [12:17<04:39, 46.44it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 37000: loss = 0.10291493684053421\n",
      "step = 37000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 74%|███████▍  | 37106/50000 [12:19<03:52, 55.49it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 37100: loss = 0.06743651628494263\n",
      "step = 37100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 74%|███████▍  | 37210/50000 [12:21<04:01, 53.04it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 37200: loss = 0.17498411238193512\n",
      "step = 37200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|███████▍  | 37311/50000 [12:23<03:59, 53.04it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 37300: loss = 0.08153637498617172\n",
      "step = 37300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|███████▍  | 37405/50000 [12:25<04:26, 47.30it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 37400: loss = 0.10706575959920883\n",
      "step = 37400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|███████▌  | 37508/50000 [12:27<03:57, 52.69it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 37500: loss = 0.09754341095685959\n",
      "step = 37500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|███████▌  | 37604/50000 [12:29<04:20, 47.63it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 37600: loss = 0.07427927106618881\n",
      "step = 37600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|███████▌  | 37710/50000 [12:31<03:45, 54.59it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 37700: loss = 0.12453631311655045\n",
      "step = 37700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 76%|███████▌  | 37804/50000 [12:33<04:22, 46.55it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 37800: loss = 0.09662196040153503\n",
      "step = 37800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 76%|███████▌  | 37906/50000 [12:35<04:10, 48.27it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 37900: loss = 0.08059288561344147\n",
      "step = 37900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 76%|███████▌  | 38010/50000 [12:37<03:50, 52.10it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 38000: loss = 0.057574909180402756\n",
      "step = 38000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 76%|███████▌  | 38103/50000 [12:39<04:14, 46.79it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 38100: loss = 0.13719286024570465\n",
      "step = 38100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 76%|███████▋  | 38203/50000 [12:41<03:55, 50.03it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 38200: loss = 0.12739771604537964\n",
      "step = 38200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 77%|███████▋  | 38310/50000 [12:43<03:28, 56.11it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 38300: loss = 0.1255558431148529\n",
      "step = 38300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 77%|███████▋  | 38406/50000 [12:45<03:35, 53.88it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 38400: loss = 0.08317247033119202\n",
      "step = 38400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 77%|███████▋  | 38508/50000 [12:47<03:40, 52.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 38500: loss = 0.10384677350521088\n",
      "step = 38500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 77%|███████▋  | 38607/50000 [12:49<03:55, 48.30it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 38600: loss = 0.08487268537282944\n",
      "step = 38600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 77%|███████▋  | 38708/50000 [12:51<03:33, 52.97it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 38700: loss = 0.1374323070049286\n",
      "step = 38700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 78%|███████▊  | 38809/50000 [12:53<03:31, 52.99it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 38800: loss = 0.13615921139717102\n",
      "step = 38800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 78%|███████▊  | 38905/50000 [12:55<04:00, 46.05it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 38900: loss = 0.05907376855611801\n",
      "step = 38900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 78%|███████▊  | 39011/50000 [12:57<03:22, 54.18it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 39000: loss = 0.08231460303068161\n",
      "step = 39000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 78%|███████▊  | 39105/50000 [12:59<03:12, 56.59it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 39100: loss = 0.05946527421474457\n",
      "step = 39100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 78%|███████▊  | 39207/50000 [13:01<03:49, 47.10it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 39200: loss = 0.08521539717912674\n",
      "step = 39200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 79%|███████▊  | 39308/50000 [13:03<03:35, 49.53it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 39300: loss = 0.06630321592092514\n",
      "step = 39300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 79%|███████▉  | 39410/50000 [13:05<03:24, 51.78it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 39400: loss = 0.05432610586285591\n",
      "step = 39400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 79%|███████▉  | 39506/50000 [13:06<02:59, 58.32it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 39500: loss = 0.1006699800491333\n",
      "step = 39500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 79%|███████▉  | 39607/50000 [13:08<03:56, 43.95it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 39600: loss = 0.09175581485033035\n",
      "step = 39600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 79%|███████▉  | 39706/50000 [13:11<03:40, 46.64it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 39700: loss = 0.05033111572265625\n",
      "step = 39700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|███████▉  | 39808/50000 [13:13<03:30, 48.40it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 39800: loss = 0.02641076222062111\n",
      "step = 39800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|███████▉  | 39906/50000 [13:15<03:23, 49.62it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 39900: loss = 0.06510841846466064\n",
      "step = 39900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████  | 40003/50000 [13:17<03:04, 54.23it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 40000: loss = 0.0994998961687088\n",
      "step = 40000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████  | 40111/50000 [13:19<03:01, 54.47it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 40100: loss = 0.058151811361312866\n",
      "step = 40100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████  | 40207/50000 [13:21<03:00, 54.21it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 40200: loss = 0.04196016490459442\n",
      "step = 40200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 81%|████████  | 40303/50000 [13:22<03:37, 44.66it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 40300: loss = 0.08752907812595367\n",
      "step = 40300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 81%|████████  | 40410/50000 [13:25<02:53, 55.41it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 40400: loss = 0.12137958407402039\n",
      "step = 40400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 81%|████████  | 40506/50000 [13:26<03:11, 49.65it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 40500: loss = 0.06445014476776123\n",
      "step = 40500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 81%|████████  | 40608/50000 [13:28<02:48, 55.83it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 40600: loss = 0.09130574017763138\n",
      "step = 40600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 81%|████████▏ | 40704/50000 [13:30<03:06, 49.82it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 40700: loss = 0.07477296888828278\n",
      "step = 40700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 82%|████████▏ | 40806/50000 [13:32<02:53, 53.04it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 40800: loss = 0.07320969551801682\n",
      "step = 40800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 82%|████████▏ | 40907/50000 [13:34<03:07, 48.41it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 40900: loss = 0.08559858798980713\n",
      "step = 40900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 82%|████████▏ | 41009/50000 [13:36<02:49, 53.00it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 41000: loss = 0.12075398862361908\n",
      "step = 41000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 82%|████████▏ | 41107/50000 [13:38<02:38, 56.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 41100: loss = 0.15398210287094116\n",
      "step = 41100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 82%|████████▏ | 41208/50000 [13:40<03:00, 48.84it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 41200: loss = 0.06781940162181854\n",
      "step = 41200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 83%|████████▎ | 41307/50000 [13:42<02:57, 49.09it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 41300: loss = 0.07528483867645264\n",
      "step = 41300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 83%|████████▎ | 41408/50000 [13:44<02:40, 53.51it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 41400: loss = 0.08662624657154083\n",
      "step = 41400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 83%|████████▎ | 41504/50000 [13:46<02:41, 52.58it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 41500: loss = 0.0561070516705513\n",
      "step = 41500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 83%|████████▎ | 41607/50000 [13:48<02:40, 52.27it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 41600: loss = 0.062262162566185\n",
      "step = 41600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 83%|████████▎ | 41709/50000 [13:50<02:30, 55.03it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 41700: loss = 0.06503522396087646\n",
      "step = 41700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 84%|████████▎ | 41804/50000 [13:52<02:52, 47.55it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 41800: loss = 0.06855951994657516\n",
      "step = 41800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 84%|████████▍ | 41906/50000 [13:54<02:47, 48.38it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 41900: loss = 0.08694839477539062\n",
      "step = 41900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 84%|████████▍ | 42006/50000 [13:56<02:45, 48.44it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 42000: loss = 0.07643837481737137\n",
      "step = 42000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 84%|████████▍ | 42107/50000 [13:58<02:31, 52.04it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 42100: loss = 0.11618570983409882\n",
      "step = 42100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 84%|████████▍ | 42209/50000 [14:00<02:22, 54.62it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 42200: loss = 0.1206330806016922\n",
      "step = 42200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████▍ | 42310/50000 [14:02<02:24, 53.22it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 42300: loss = 0.07547008991241455\n",
      "step = 42300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████▍ | 42408/50000 [14:04<02:22, 53.10it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 42400: loss = 0.04188406839966774\n",
      "step = 42400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████▌ | 42504/50000 [14:06<02:25, 51.50it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 42500: loss = 0.09186878055334091\n",
      "step = 42500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████▌ | 42609/50000 [14:08<02:22, 51.82it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 42600: loss = 0.03656727448105812\n",
      "step = 42600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████▌ | 42708/50000 [14:10<02:34, 47.33it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 42700: loss = 0.0609370656311512\n",
      "step = 42700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 86%|████████▌ | 42807/50000 [14:12<02:22, 50.53it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 42800: loss = 0.05573431774973869\n",
      "step = 42800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 86%|████████▌ | 42906/50000 [14:14<02:21, 49.98it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 42900: loss = 0.06956863403320312\n",
      "step = 42900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 86%|████████▌ | 43009/50000 [14:16<02:28, 47.10it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 43000: loss = 0.12670062482357025\n",
      "step = 43000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 86%|████████▌ | 43106/50000 [14:18<02:11, 52.49it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 43100: loss = 0.07492081075906754\n",
      "step = 43100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 86%|████████▋ | 43208/50000 [14:20<02:13, 51.05it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 43200: loss = 0.10065560787916183\n",
      "step = 43200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 87%|████████▋ | 43308/50000 [14:22<02:22, 46.93it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 43300: loss = 0.08686584234237671\n",
      "step = 43300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 87%|████████▋ | 43410/50000 [14:24<01:59, 55.12it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 43400: loss = 0.0829373151063919\n",
      "step = 43400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 87%|████████▋ | 43509/50000 [14:26<02:11, 49.24it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 43500: loss = 0.05544828623533249\n",
      "step = 43500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 87%|████████▋ | 43606/50000 [14:28<02:11, 48.73it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 43600: loss = 0.05720590054988861\n",
      "step = 43600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 87%|████████▋ | 43709/50000 [14:30<02:16, 46.20it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 43700: loss = 0.042639024555683136\n",
      "step = 43700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 88%|████████▊ | 43806/50000 [14:32<02:13, 46.41it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 43800: loss = 0.06993471831083298\n",
      "step = 43800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 88%|████████▊ | 43908/50000 [14:34<01:56, 52.29it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 43900: loss = 0.10885415226221085\n",
      "step = 43900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 88%|████████▊ | 44003/50000 [14:36<02:02, 48.88it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 44000: loss = 0.06340458989143372\n",
      "step = 44000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 88%|████████▊ | 44105/50000 [14:38<01:57, 50.11it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 44100: loss = 0.06285019218921661\n",
      "step = 44100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 88%|████████▊ | 44206/50000 [14:40<01:55, 50.34it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 44200: loss = 0.1052529364824295\n",
      "step = 44200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 89%|████████▊ | 44304/50000 [14:42<02:02, 46.47it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 44300: loss = 0.08845879882574081\n",
      "step = 44300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 89%|████████▉ | 44410/50000 [14:44<01:46, 52.45it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 44400: loss = 0.047976695001125336\n",
      "step = 44400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 89%|████████▉ | 44509/50000 [14:46<01:48, 50.71it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 44500: loss = 0.0949396938085556\n",
      "step = 44500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 89%|████████▉ | 44607/50000 [14:48<01:41, 52.96it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 44600: loss = 0.11101000756025314\n",
      "step = 44600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 89%|████████▉ | 44707/50000 [14:50<01:47, 49.32it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 44700: loss = 0.0739651471376419\n",
      "step = 44700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████▉ | 44807/50000 [14:52<01:47, 48.20it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 44800: loss = 0.07227924466133118\n",
      "step = 44800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████▉ | 44908/50000 [14:54<01:46, 47.97it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 44900: loss = 0.06186581030488014\n",
      "step = 44900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|█████████ | 45010/50000 [14:56<01:38, 50.79it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 45000: loss = 0.05273433029651642\n",
      "step = 45000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|█████████ | 45106/50000 [14:58<01:28, 55.38it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 45100: loss = 0.08795061707496643\n",
      "step = 45100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|█████████ | 45207/50000 [15:00<01:35, 50.13it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 45200: loss = 0.04860900342464447\n",
      "step = 45200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 91%|█████████ | 45310/50000 [15:02<01:21, 57.54it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 45300: loss = 0.09708148241043091\n",
      "step = 45300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 91%|█████████ | 45404/50000 [15:04<01:28, 52.16it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 45400: loss = 0.06970957666635513\n",
      "step = 45400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 91%|█████████ | 45507/50000 [15:05<01:18, 57.34it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 45500: loss = 0.09576451778411865\n",
      "step = 45500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 91%|█████████ | 45606/50000 [15:08<01:39, 44.03it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 45600: loss = 0.08589446544647217\n",
      "step = 45600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 91%|█████████▏| 45709/50000 [15:10<01:22, 51.75it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 45700: loss = 0.13611505925655365\n",
      "step = 45700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 92%|█████████▏| 45811/50000 [15:12<01:15, 55.44it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 45800: loss = 0.10860997438430786\n",
      "step = 45800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 92%|█████████▏| 45907/50000 [15:13<01:16, 53.25it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 45900: loss = 0.07697451114654541\n",
      "step = 45900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 92%|█████████▏| 46008/50000 [15:15<01:13, 54.14it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 46000: loss = 0.07978943735361099\n",
      "step = 46000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 92%|█████████▏| 46108/50000 [15:17<01:23, 46.70it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 46100: loss = 0.05577067285776138\n",
      "step = 46100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 92%|█████████▏| 46209/50000 [15:19<01:16, 49.79it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 46200: loss = 0.1001177579164505\n",
      "step = 46200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 93%|█████████▎| 46310/50000 [15:22<01:13, 50.31it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 46300: loss = 0.14295047521591187\n",
      "step = 46300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 93%|█████████▎| 46409/50000 [15:24<01:08, 52.76it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 46400: loss = 0.09782980382442474\n",
      "step = 46400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 93%|█████████▎| 46508/50000 [15:26<01:11, 48.70it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 46500: loss = 0.06264971196651459\n",
      "step = 46500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 93%|█████████▎| 46609/50000 [15:28<01:11, 47.59it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 46600: loss = 0.08794581890106201\n",
      "step = 46600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 93%|█████████▎| 46708/50000 [15:30<01:01, 53.50it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 46700: loss = 0.08841992914676666\n",
      "step = 46700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 94%|█████████▎| 46809/50000 [15:32<01:00, 52.96it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 46800: loss = 0.03269673138856888\n",
      "step = 46800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 94%|█████████▍| 46907/50000 [15:34<01:03, 48.72it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 46900: loss = 0.08828985691070557\n",
      "step = 46900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 94%|█████████▍| 47009/50000 [15:36<01:00, 49.17it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 47000: loss = 0.07194104790687561\n",
      "step = 47000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 94%|█████████▍| 47106/50000 [15:37<00:49, 58.90it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 47100: loss = 0.08745653927326202\n",
      "step = 47100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 94%|█████████▍| 47207/50000 [15:39<00:57, 48.74it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 47200: loss = 0.08969800174236298\n",
      "step = 47200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|█████████▍| 47309/50000 [15:41<00:49, 54.80it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 47300: loss = 0.09731223434209824\n",
      "step = 47300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|█████████▍| 47411/50000 [15:43<00:49, 52.77it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 47400: loss = 0.11740436404943466\n",
      "step = 47400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|█████████▌| 47511/50000 [15:45<00:46, 53.48it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 47500: loss = 0.060255154967308044\n",
      "step = 47500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|█████████▌| 47605/50000 [15:47<00:55, 43.41it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 47600: loss = 0.06413909047842026\n",
      "step = 47600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|█████████▌| 47708/50000 [15:49<00:47, 48.55it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 47700: loss = 0.06182767450809479\n",
      "step = 47700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 96%|█████████▌| 47810/50000 [15:51<00:43, 50.86it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 47800: loss = 0.06960432231426239\n",
      "step = 47800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 96%|█████████▌| 47906/50000 [15:53<00:38, 54.82it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 47900: loss = 0.058453306555747986\n",
      "step = 47900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 96%|█████████▌| 48006/50000 [15:55<00:41, 48.38it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 48000: loss = 0.02796155773103237\n",
      "step = 48000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 96%|█████████▌| 48105/50000 [15:57<00:37, 49.99it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 48100: loss = 0.059160083532333374\n",
      "step = 48100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 96%|█████████▋| 48206/50000 [15:59<00:37, 47.83it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 48200: loss = 0.09901007264852524\n",
      "step = 48200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 97%|█████████▋| 48306/50000 [16:01<00:31, 53.36it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 48300: loss = 0.07654702663421631\n",
      "step = 48300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 97%|█████████▋| 48405/50000 [16:03<00:33, 47.16it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 48400: loss = 0.07349776476621628\n",
      "step = 48400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 97%|█████████▋| 48510/50000 [16:05<00:28, 52.19it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 48500: loss = 0.0637381374835968\n",
      "step = 48500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 97%|█████████▋| 48607/50000 [16:07<00:28, 49.54it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 48600: loss = 0.10158848762512207\n",
      "step = 48600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 97%|█████████▋| 48708/50000 [16:09<00:23, 54.60it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 48700: loss = 0.05271802097558975\n",
      "step = 48700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 98%|█████████▊| 48808/50000 [16:11<00:26, 45.74it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 48800: loss = 0.09254822134971619\n",
      "step = 48800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 98%|█████████▊| 48906/50000 [16:13<00:25, 42.38it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 48900: loss = 0.07700479030609131\n",
      "step = 48900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 98%|█████████▊| 49011/50000 [16:15<00:16, 58.27it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 49000: loss = 0.10161009430885315\n",
      "step = 49000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 98%|█████████▊| 49110/50000 [16:17<00:17, 51.49it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 49100: loss = 0.08305716514587402\n",
      "step = 49100: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 98%|█████████▊| 49205/50000 [16:19<00:15, 50.95it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 49200: loss = 0.06167404726147652\n",
      "step = 49200: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|█████████▊| 49308/50000 [16:21<00:13, 52.88it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 49300: loss = 0.0743592232465744\n",
      "step = 49300: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|█████████▉| 49408/50000 [16:23<00:11, 50.95it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 49400: loss = 0.08947211503982544\n",
      "step = 49400: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|█████████▉| 49507/50000 [16:25<00:09, 50.46it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 49500: loss = 0.09325367957353592\n",
      "step = 49500: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|█████████▉| 49604/50000 [16:27<00:08, 44.36it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 49600: loss = 0.04487597942352295\n",
      "step = 49600: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|█████████▉| 49709/50000 [16:29<00:05, 50.23it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 49700: loss = 0.08183963596820831\n",
      "step = 49700: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████▉| 49805/50000 [16:31<00:04, 47.68it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 49800: loss = 0.0537743866443634\n",
      "step = 49800: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████▉| 49908/50000 [16:33<00:01, 51.04it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 49900: loss = 0.06310667097568512\n",
      "step = 49900: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 50000/50000 [16:35<00:00, 50.22it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 50000: loss = 0.052112311124801636\n",
      "step = 50000: Average reward = 0.74603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "agent.train = common.function(agent.train)\n",
    "# Reset the train step\n",
    "agent.train_step_counter.assign(0)\n",
    "agent.initialize()\n",
    "\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",
    "\n",
    "loss = []\n",
    "returns = []\n",
    "observations = []\n",
    "rewards = []\n",
    "time_step = None\n",
    "eval_interval = 100 \n",
    "loss_interval = 100\n",
    "total_return = 0.0\n",
    "# time_step = None\n",
    "time_step = eval_env.reset()\n",
    "policy_state = agent.collect_policy.get_initial_state(train_env.batch_size)\n",
    "\n",
    "# for _ in tqdm(range(100)):\n",
    "for _ in tqdm(range(50000)):\n",
    "  # Sample a batch of data from the buffer and update the agent's network.\n",
    "  # time_step, _ = collect_driver.run(time_step)\n",
    "\n",
    "  for _ in range(collect_steps_per_iteration):\n",
    "    collect_step(train_env, agent.policy)\n",
    "\n",
    "  experience, buffer_info = next(iterator)\n",
    "  train_loss = agent.train(experience)\n",
    "\n",
    "  # # Calculate a reward\n",
    "  policy_step = agent.policy.action(time_step, seed=42)\n",
    "  time_step = eval_env.step(policy_step.action)\n",
    "  rwd = time_step.reward.numpy()[0]\n",
    "  obs = time_step.observation.numpy()[0]\n",
    "  total_return += rwd # Calculate a sum of rewards\n",
    "\n",
    "  step = agent.train_step_counter.numpy()\n",
    "\n",
    "  # Log\n",
    "  # print(f\"step = {step}: observation = {obs}, reward = {rwd}\")\n",
    "  observations.append(obs)\n",
    "  rewards.append(rwd)\n",
    "  \n",
    "  if step % loss_interval == 0:\n",
    "    print(f\"step = {step}: loss = {train_loss.loss}\")\n",
    "    loss.append(train_loss.loss)\n",
    "\n",
    "  if step % eval_interval == 0:\n",
    "    # avg_return = compute_avg_return(eval_env, agent.policy, 10)\n",
    "    avg_return = total_return / eval_interval\n",
    "    print('step = {0}: Average reward = {1:.5f}'.format(step, avg_return))\n",
    "    returns.append(avg_return)\n",
    "    total_return = 0.0 # reset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>7</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>7</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>7</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49995</th>\n",
       "      <td>7</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49996</th>\n",
       "      <td>7</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49997</th>\n",
       "      <td>7</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49998</th>\n",
       "      <td>7</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49999</th>\n",
       "      <td>7</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>50000 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "       0   1\n",
       "0      7  12\n",
       "1      1  12\n",
       "2      7  12\n",
       "3      7  12\n",
       "4      1  12\n",
       "...   ..  ..\n",
       "49995  7   8\n",
       "49996  7   8\n",
       "49997  7   8\n",
       "49998  7   8\n",
       "49999  7   8\n",
       "\n",
       "[50000 rows x 2 columns]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(observations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(returns, label=\"Rewards\")\n",
    "plt.xlabel('Step')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(loss, label=\"Loss\", c='r')\n",
    "# plt.plot(returns, label=\"Rewards\")\n",
    "plt.xlabel('Step')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save to checkpoint."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:absl:Saved checkpoint: tmp/checkpoint/ckpt-15000\n"
     ]
    }
   ],
   "source": [
    "train_checkpointer.save(global_step)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Restore checkpoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 16/10000 [00:00<01:03, 158.24it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: Average reward = 0.00493\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|          | 123/10000 [00:00<00:56, 173.69it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: Average reward = 0.24630\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  2%|▏         | 236/10000 [00:01<00:53, 181.44it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: Average reward = 0.24630\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  3%|▎         | 331/10000 [00:01<00:52, 184.25it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: Average reward = 0.24630\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  4%|▍         | 426/10000 [00:02<00:51, 185.28it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: Average reward = 0.24630\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|▌         | 521/10000 [00:02<00:51, 184.63it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: Average reward = 0.24630\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  6%|▋         | 635/10000 [00:03<00:50, 185.36it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: Average reward = 0.24630\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  7%|▋         | 730/10000 [00:04<00:49, 185.43it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: Average reward = 0.24630\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  8%|▊         | 825/10000 [00:04<00:49, 184.41it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: Average reward = 0.24630\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  9%|▉         | 920/10000 [00:05<00:49, 185.14it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: Average reward = 0.24630\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|█         | 1034/10000 [00:05<00:48, 185.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: Average reward = 0.24630\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 11%|█▏        | 1129/10000 [00:06<00:47, 185.40it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: Average reward = 0.24630\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 12%|█▏        | 1224/10000 [00:06<00:47, 185.04it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: Average reward = 0.24630\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 13%|█▎        | 1338/10000 [00:07<00:46, 185.41it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: Average reward = 0.24630\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 14%|█▍        | 1433/10000 [00:07<00:46, 184.49it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: Average reward = 0.24630\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|█▌        | 1502/10000 [00:08<00:46, 182.73it/s]\n",
      "/home/vsakovskaya/my-env/lib/python3.9/site-packages/tf_agents/policies/tf_policy.py:253: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "  if policy_state is ():  # pylint: disable=literal-comparison\n",
      "/home/vsakovskaya/my-env/lib/python3.9/site-packages/tf_agents/policies/tf_policy.py:315: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "  if not (policy_state is None or policy_state is () or policy_state is []):  # pylint: disable=literal-comparison\n",
      "/home/vsakovskaya/my-env/lib/python3.9/site-packages/tf_agents/policies/tf_policy.py:253: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "  if policy_state is ():  # pylint: disable=literal-comparison\n",
      "/home/vsakovskaya/my-env/lib/python3.9/site-packages/tf_agents/policies/tf_policy.py:315: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "  if not (policy_state is None or policy_state is () or policy_state is []):  # pylint: disable=literal-comparison\n",
      "/home/vsakovskaya/my-env/lib/python3.9/site-packages/tf_agents/utils/common.py:1443: SyntaxWarning: \"is not\" with a literal. Did you mean \"!=\"?\n",
      "  return state is not None and state is not () and state is not []\n",
      "/home/vsakovskaya/my-env/lib/python3.9/site-packages/tf_agents/utils/common.py:1443: SyntaxWarning: \"is not\" with a literal. Did you mean \"!=\"?\n",
      "  return state is not None and state is not () and state is not []\n",
      "/home/vsakovskaya/my-env/lib/python3.9/site-packages/tf_agents/policies/tf_policy.py:253: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "  if policy_state is ():  # pylint: disable=literal-comparison\n",
      "/home/vsakovskaya/my-env/lib/python3.9/site-packages/tf_agents/policies/tf_policy.py:315: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "  if not (policy_state is None or policy_state is () or policy_state is []):  # pylint: disable=literal-comparison\n",
      "/home/vsakovskaya/my-env/lib/python3.9/site-packages/tf_agents/policies/tf_policy.py:253: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "  if policy_state is ():  # pylint: disable=literal-comparison\n",
      "/home/vsakovskaya/my-env/lib/python3.9/site-packages/tf_agents/policies/tf_policy.py:315: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "  if not (policy_state is None or policy_state is () or policy_state is []):  # pylint: disable=literal-comparison\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step = 20000: Average reward = 0.24630\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[29], line 33\u001b[0m\n\u001b[1;32m     18\u001b[0m     \u001b[39mreturn\u001b[39;00m rewards\n\u001b[1;32m     20\u001b[0m \u001b[39m# The whole set of objects should be recreated \u001b[39;00m\n\u001b[1;32m     21\u001b[0m \u001b[39m# the same way as when the checkpoint was created.\u001b[39;00m\n\u001b[1;32m     22\u001b[0m \u001b[39m# train_checkpointer.initialize_or_restore()\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     31\u001b[0m \u001b[39m# Load the saved policy and check how it performs.\u001b[39;00m\n\u001b[1;32m     32\u001b[0m \u001b[39m# saved_policy = tf.saved_model.load(policy_dir)\u001b[39;00m\n\u001b[0;32m---> 33\u001b[0m test(agent\u001b[39m.\u001b[39;49mpolicy, test_env)\n\u001b[1;32m     34\u001b[0m \u001b[39m# print(reward)\u001b[39;00m\n\u001b[1;32m     35\u001b[0m \n\u001b[1;32m     36\u001b[0m \u001b[39m# saved_res = compute_avg_return(eval_env, saved_policy, num_episodes=20)\u001b[39;00m\n\u001b[1;32m     37\u001b[0m \u001b[39m# random_res = compute_avg_return(eval_env, random_policy, num_episodes=20)\u001b[39;00m\n",
      "Cell \u001b[0;32mIn[29], line 7\u001b[0m, in \u001b[0;36mtest\u001b[0;34m(policy, test_env, num_episodes)\u001b[0m\n\u001b[1;32m      5\u001b[0m total_return \u001b[39m=\u001b[39m \u001b[39m0.0\u001b[39m\n\u001b[1;32m      6\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m tqdm(\u001b[39mrange\u001b[39m(\u001b[39m10000\u001b[39m)):\n\u001b[0;32m----> 7\u001b[0m     policy_state \u001b[39m=\u001b[39m policy\u001b[39m.\u001b[39;49maction(time_step)\n\u001b[1;32m      8\u001b[0m     time_step \u001b[39m=\u001b[39m test_env\u001b[39m.\u001b[39mstep(policy_state\u001b[39m.\u001b[39maction)\n\u001b[1;32m      9\u001b[0m     reward \u001b[39m=\u001b[39m time_step\u001b[39m.\u001b[39mreward\u001b[39m.\u001b[39mnumpy()[\u001b[39m0\u001b[39m]\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/tf_agents/policies/tf_policy.py:324\u001b[0m, in \u001b[0;36mTFPolicy.action\u001b[0;34m(self, time_step, policy_state, seed)\u001b[0m\n\u001b[1;32m    322\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_automatic_state_reset:\n\u001b[1;32m    323\u001b[0m   policy_state \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_maybe_reset_state(time_step, policy_state)\n\u001b[0;32m--> 324\u001b[0m step \u001b[39m=\u001b[39m action_fn(time_step\u001b[39m=\u001b[39;49mtime_step, policy_state\u001b[39m=\u001b[39;49mpolicy_state, seed\u001b[39m=\u001b[39;49mseed)\n\u001b[1;32m    326\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mclip_action\u001b[39m(action, action_spec):\n\u001b[1;32m    327\u001b[0m   \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(action_spec, tensor_spec\u001b[39m.\u001b[39mBoundedTensorSpec):\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/tf_agents/utils/common.py:188\u001b[0m, in \u001b[0;36mfunction_in_tf1.<locals>.maybe_wrap.<locals>.with_check_resource_vars\u001b[0;34m(*fn_args, **fn_kwargs)\u001b[0m\n\u001b[1;32m    184\u001b[0m check_tf1_allowed()\n\u001b[1;32m    185\u001b[0m \u001b[39mif\u001b[39;00m has_eager_been_enabled():\n\u001b[1;32m    186\u001b[0m   \u001b[39m# We're either in eager mode or in tf.function mode (no in-between); so\u001b[39;00m\n\u001b[1;32m    187\u001b[0m   \u001b[39m# autodep-like behavior is already expected of fn.\u001b[39;00m\n\u001b[0;32m--> 188\u001b[0m   \u001b[39mreturn\u001b[39;00m fn(\u001b[39m*\u001b[39;49mfn_args, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mfn_kwargs)\n\u001b[1;32m    189\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m resource_variables_enabled():\n\u001b[1;32m    190\u001b[0m   \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(MISSING_RESOURCE_VARIABLES_ERROR)\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/tf_agents/policies/tf_policy.py:560\u001b[0m, in \u001b[0;36mTFPolicy._action\u001b[0;34m(self, time_step, policy_state, seed)\u001b[0m\n\u001b[1;32m    545\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Implementation of `action`.\u001b[39;00m\n\u001b[1;32m    546\u001b[0m \n\u001b[1;32m    547\u001b[0m \u001b[39mArgs:\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    557\u001b[0m \u001b[39m    `info`: Optional side information such as action log probabilities.\u001b[39;00m\n\u001b[1;32m    558\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    559\u001b[0m seed_stream \u001b[39m=\u001b[39m tfp\u001b[39m.\u001b[39mutil\u001b[39m.\u001b[39mSeedStream(seed\u001b[39m=\u001b[39mseed, salt\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mtf_agents_tf_policy\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m--> 560\u001b[0m distribution_step \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_distribution(time_step, policy_state)  \u001b[39m# pytype: disable=wrong-arg-types\u001b[39;00m\n\u001b[1;32m    561\u001b[0m actions \u001b[39m=\u001b[39m tf\u001b[39m.\u001b[39mnest\u001b[39m.\u001b[39mmap_structure(\n\u001b[1;32m    562\u001b[0m     \u001b[39mlambda\u001b[39;00m d: reparameterized_sampling\u001b[39m.\u001b[39msample(d, seed\u001b[39m=\u001b[39mseed_stream()),\n\u001b[1;32m    563\u001b[0m     distribution_step\u001b[39m.\u001b[39maction)\n\u001b[1;32m    564\u001b[0m info \u001b[39m=\u001b[39m distribution_step\u001b[39m.\u001b[39minfo\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/tf_agents/policies/greedy_policy.py:83\u001b[0m, in \u001b[0;36mGreedyPolicy._distribution\u001b[0;34m(self, time_step, policy_state)\u001b[0m\n\u001b[1;32m     78\u001b[0m   \u001b[39mreturn\u001b[39;00m tfp\u001b[39m.\u001b[39mdistributions\u001b[39m.\u001b[39mDeterministic(loc\u001b[39m=\u001b[39mgreedy_action)\n\u001b[1;32m     80\u001b[0m distribution_step \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_wrapped_policy\u001b[39m.\u001b[39mdistribution(\n\u001b[1;32m     81\u001b[0m     time_step, policy_state)\n\u001b[1;32m     82\u001b[0m \u001b[39mreturn\u001b[39;00m policy_step\u001b[39m.\u001b[39mPolicyStep(\n\u001b[0;32m---> 83\u001b[0m     tf\u001b[39m.\u001b[39;49mnest\u001b[39m.\u001b[39;49mmap_structure(dist_fn, distribution_step\u001b[39m.\u001b[39;49maction),\n\u001b[1;32m     84\u001b[0m     distribution_step\u001b[39m.\u001b[39mstate, distribution_step\u001b[39m.\u001b[39minfo)\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/tensorflow/python/util/nest.py:624\u001b[0m, in \u001b[0;36mmap_structure\u001b[0;34m(func, *structure, **kwargs)\u001b[0m\n\u001b[1;32m    538\u001b[0m \u001b[39m@tf_export\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mnest.map_structure\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m    539\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mmap_structure\u001b[39m(func, \u001b[39m*\u001b[39mstructure, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m    540\u001b[0m \u001b[39m  \u001b[39m\u001b[39m\"\"\"Creates a new structure by applying `func` to each atom in `structure`.\u001b[39;00m\n\u001b[1;32m    541\u001b[0m \n\u001b[1;32m    542\u001b[0m \u001b[39m  Refer to [tf.nest](https://www.tensorflow.org/api_docs/python/tf/nest)\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    622\u001b[0m \u001b[39m    ValueError: If wrong keyword arguments are provided.\u001b[39;00m\n\u001b[1;32m    623\u001b[0m \u001b[39m  \"\"\"\u001b[39;00m\n\u001b[0;32m--> 624\u001b[0m   \u001b[39mreturn\u001b[39;00m nest_util\u001b[39m.\u001b[39;49mmap_structure(\n\u001b[1;32m    625\u001b[0m       nest_util\u001b[39m.\u001b[39;49mModality\u001b[39m.\u001b[39;49mCORE, func, \u001b[39m*\u001b[39;49mstructure, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs\n\u001b[1;32m    626\u001b[0m   )\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/tensorflow/python/util/nest_util.py:1054\u001b[0m, in \u001b[0;36mmap_structure\u001b[0;34m(modality, func, *structure, **kwargs)\u001b[0m\n\u001b[1;32m    957\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Creates a new structure by applying `func` to each atom in `structure`.\u001b[39;00m\n\u001b[1;32m    958\u001b[0m \n\u001b[1;32m    959\u001b[0m \u001b[39m- For Modality.CORE: Refer to\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m   1051\u001b[0m \u001b[39m  ValueError: If wrong keyword arguments are provided.\u001b[39;00m\n\u001b[1;32m   1052\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m   1053\u001b[0m \u001b[39mif\u001b[39;00m modality \u001b[39m==\u001b[39m Modality\u001b[39m.\u001b[39mCORE:\n\u001b[0;32m-> 1054\u001b[0m   \u001b[39mreturn\u001b[39;00m _tf_core_map_structure(func, \u001b[39m*\u001b[39;49mstructure, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m   1055\u001b[0m \u001b[39melif\u001b[39;00m modality \u001b[39m==\u001b[39m Modality\u001b[39m.\u001b[39mDATA:\n\u001b[1;32m   1056\u001b[0m   \u001b[39mreturn\u001b[39;00m _tf_data_map_structure(func, \u001b[39m*\u001b[39mstructure, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/tensorflow/python/util/nest_util.py:1094\u001b[0m, in \u001b[0;36m_tf_core_map_structure\u001b[0;34m(func, *structure, **kwargs)\u001b[0m\n\u001b[1;32m   1089\u001b[0m flat_structure \u001b[39m=\u001b[39m (_tf_core_flatten(s, expand_composites) \u001b[39mfor\u001b[39;00m s \u001b[39min\u001b[39;00m structure)\n\u001b[1;32m   1090\u001b[0m entries \u001b[39m=\u001b[39m \u001b[39mzip\u001b[39m(\u001b[39m*\u001b[39mflat_structure)\n\u001b[1;32m   1092\u001b[0m \u001b[39mreturn\u001b[39;00m _tf_core_pack_sequence_as(\n\u001b[1;32m   1093\u001b[0m     structure[\u001b[39m0\u001b[39m],\n\u001b[0;32m-> 1094\u001b[0m     [func(\u001b[39m*\u001b[39mx) \u001b[39mfor\u001b[39;00m x \u001b[39min\u001b[39;00m entries],\n\u001b[1;32m   1095\u001b[0m     expand_composites\u001b[39m=\u001b[39mexpand_composites,\n\u001b[1;32m   1096\u001b[0m )\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/tensorflow/python/util/nest_util.py:1094\u001b[0m, in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m   1089\u001b[0m flat_structure \u001b[39m=\u001b[39m (_tf_core_flatten(s, expand_composites) \u001b[39mfor\u001b[39;00m s \u001b[39min\u001b[39;00m structure)\n\u001b[1;32m   1090\u001b[0m entries \u001b[39m=\u001b[39m \u001b[39mzip\u001b[39m(\u001b[39m*\u001b[39mflat_structure)\n\u001b[1;32m   1092\u001b[0m \u001b[39mreturn\u001b[39;00m _tf_core_pack_sequence_as(\n\u001b[1;32m   1093\u001b[0m     structure[\u001b[39m0\u001b[39m],\n\u001b[0;32m-> 1094\u001b[0m     [func(\u001b[39m*\u001b[39;49mx) \u001b[39mfor\u001b[39;00m x \u001b[39min\u001b[39;00m entries],\n\u001b[1;32m   1095\u001b[0m     expand_composites\u001b[39m=\u001b[39mexpand_composites,\n\u001b[1;32m   1096\u001b[0m )\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/tf_agents/policies/greedy_policy.py:78\u001b[0m, in \u001b[0;36mGreedyPolicy._distribution.<locals>.dist_fn\u001b[0;34m(dist)\u001b[0m\n\u001b[1;32m     73\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mNotImplementedError\u001b[39;00m:\n\u001b[1;32m     74\u001b[0m   \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mYour network\u001b[39m\u001b[39m'\u001b[39m\u001b[39ms distribution does not implement mode \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m     75\u001b[0m                    \u001b[39m'\u001b[39m\u001b[39mmaking it incompatible with a greedy policy.\u001b[39m\u001b[39m'\u001b[39m\n\u001b[1;32m     76\u001b[0m                   ) \u001b[39mfrom\u001b[39;00m \u001b[39mNotImplementedError\u001b[39;00m\n\u001b[0;32m---> 78\u001b[0m \u001b[39mreturn\u001b[39;00m tfp\u001b[39m.\u001b[39;49mdistributions\u001b[39m.\u001b[39;49mDeterministic(loc\u001b[39m=\u001b[39;49mgreedy_action)\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/decorator.py:232\u001b[0m, in \u001b[0;36mdecorate.<locals>.fun\u001b[0;34m(*args, **kw)\u001b[0m\n\u001b[1;32m    230\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m kwsyntax:\n\u001b[1;32m    231\u001b[0m     args, kw \u001b[39m=\u001b[39m fix(args, kw, sig)\n\u001b[0;32m--> 232\u001b[0m \u001b[39mreturn\u001b[39;00m caller(func, \u001b[39m*\u001b[39;49m(extras \u001b[39m+\u001b[39;49m args), \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkw)\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/tensorflow_probability/python/distributions/distribution.py:342\u001b[0m, in \u001b[0;36m_DistributionMeta.__new__.<locals>.wrapped_init\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m    339\u001b[0m \u001b[39m# Note: if we ever want to have things set in `self` before `__init__` is\u001b[39;00m\n\u001b[1;32m    340\u001b[0m \u001b[39m# called, here is the place to do it.\u001b[39;00m\n\u001b[1;32m    341\u001b[0m self_\u001b[39m.\u001b[39m_parameters \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m--> 342\u001b[0m default_init(self_, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m    343\u001b[0m \u001b[39m# Note: if we ever want to override things set in `self` by subclass\u001b[39;00m\n\u001b[1;32m    344\u001b[0m \u001b[39m# `__init__`, here is the place to do it.\u001b[39;00m\n\u001b[1;32m    345\u001b[0m \u001b[39mif\u001b[39;00m self_\u001b[39m.\u001b[39m_parameters \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m    346\u001b[0m   \u001b[39m# We prefer subclasses will set `parameters = dict(locals())` because\u001b[39;00m\n\u001b[1;32m    347\u001b[0m   \u001b[39m# this has nearly zero overhead. However, failing to do this, we will\u001b[39;00m\n\u001b[1;32m    348\u001b[0m   \u001b[39m# resolve the input arguments dynamically and only when needed.\u001b[39;00m\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/tensorflow_probability/python/distributions/deterministic.py:283\u001b[0m, in \u001b[0;36mDeterministic.__init__\u001b[0;34m(self, loc, atol, rtol, validate_args, allow_nan_stats, name)\u001b[0m\n\u001b[1;32m    252\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Initialize a scalar `Deterministic` distribution.\u001b[39;00m\n\u001b[1;32m    253\u001b[0m \n\u001b[1;32m    254\u001b[0m \u001b[39mThe `atol` and `rtol` parameters allow for some slack in `pmf`, `cdf`\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    280\u001b[0m \u001b[39m  name: Python `str` name prefixed to Ops created by this class.\u001b[39;00m\n\u001b[1;32m    281\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    282\u001b[0m parameters \u001b[39m=\u001b[39m \u001b[39mdict\u001b[39m(\u001b[39mlocals\u001b[39m())\n\u001b[0;32m--> 283\u001b[0m \u001b[39msuper\u001b[39;49m(Deterministic, \u001b[39mself\u001b[39;49m)\u001b[39m.\u001b[39;49m\u001b[39m__init__\u001b[39;49m(\n\u001b[1;32m    284\u001b[0m     loc,\n\u001b[1;32m    285\u001b[0m     atol\u001b[39m=\u001b[39;49matol,\n\u001b[1;32m    286\u001b[0m     rtol\u001b[39m=\u001b[39;49mrtol,\n\u001b[1;32m    287\u001b[0m     validate_args\u001b[39m=\u001b[39;49mvalidate_args,\n\u001b[1;32m    288\u001b[0m     allow_nan_stats\u001b[39m=\u001b[39;49mallow_nan_stats,\n\u001b[1;32m    289\u001b[0m     parameters\u001b[39m=\u001b[39;49mparameters,\n\u001b[1;32m    290\u001b[0m     name\u001b[39m=\u001b[39;49mname)\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/decorator.py:232\u001b[0m, in \u001b[0;36mdecorate.<locals>.fun\u001b[0;34m(*args, **kw)\u001b[0m\n\u001b[1;32m    230\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m kwsyntax:\n\u001b[1;32m    231\u001b[0m     args, kw \u001b[39m=\u001b[39m fix(args, kw, sig)\n\u001b[0;32m--> 232\u001b[0m \u001b[39mreturn\u001b[39;00m caller(func, \u001b[39m*\u001b[39;49m(extras \u001b[39m+\u001b[39;49m args), \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkw)\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/tensorflow_probability/python/distributions/distribution.py:342\u001b[0m, in \u001b[0;36m_DistributionMeta.__new__.<locals>.wrapped_init\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m    339\u001b[0m \u001b[39m# Note: if we ever want to have things set in `self` before `__init__` is\u001b[39;00m\n\u001b[1;32m    340\u001b[0m \u001b[39m# called, here is the place to do it.\u001b[39;00m\n\u001b[1;32m    341\u001b[0m self_\u001b[39m.\u001b[39m_parameters \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m--> 342\u001b[0m default_init(self_, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m    343\u001b[0m \u001b[39m# Note: if we ever want to override things set in `self` by subclass\u001b[39;00m\n\u001b[1;32m    344\u001b[0m \u001b[39m# `__init__`, here is the place to do it.\u001b[39;00m\n\u001b[1;32m    345\u001b[0m \u001b[39mif\u001b[39;00m self_\u001b[39m.\u001b[39m_parameters \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m    346\u001b[0m   \u001b[39m# We prefer subclasses will set `parameters = dict(locals())` because\u001b[39;00m\n\u001b[1;32m    347\u001b[0m   \u001b[39m# this has nearly zero overhead. However, failing to do this, we will\u001b[39;00m\n\u001b[1;32m    348\u001b[0m   \u001b[39m# resolve the input arguments dynamically and only when needed.\u001b[39;00m\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/decorator.py:232\u001b[0m, in \u001b[0;36mdecorate.<locals>.fun\u001b[0;34m(*args, **kw)\u001b[0m\n\u001b[1;32m    230\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m kwsyntax:\n\u001b[1;32m    231\u001b[0m     args, kw \u001b[39m=\u001b[39m fix(args, kw, sig)\n\u001b[0;32m--> 232\u001b[0m \u001b[39mreturn\u001b[39;00m caller(func, \u001b[39m*\u001b[39;49m(extras \u001b[39m+\u001b[39;49m args), \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkw)\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/tensorflow_probability/python/distributions/distribution.py:342\u001b[0m, in \u001b[0;36m_DistributionMeta.__new__.<locals>.wrapped_init\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m    339\u001b[0m \u001b[39m# Note: if we ever want to have things set in `self` before `__init__` is\u001b[39;00m\n\u001b[1;32m    340\u001b[0m \u001b[39m# called, here is the place to do it.\u001b[39;00m\n\u001b[1;32m    341\u001b[0m self_\u001b[39m.\u001b[39m_parameters \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m--> 342\u001b[0m default_init(self_, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m    343\u001b[0m \u001b[39m# Note: if we ever want to override things set in `self` by subclass\u001b[39;00m\n\u001b[1;32m    344\u001b[0m \u001b[39m# `__init__`, here is the place to do it.\u001b[39;00m\n\u001b[1;32m    345\u001b[0m \u001b[39mif\u001b[39;00m self_\u001b[39m.\u001b[39m_parameters \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m    346\u001b[0m   \u001b[39m# We prefer subclasses will set `parameters = dict(locals())` because\u001b[39;00m\n\u001b[1;32m    347\u001b[0m   \u001b[39m# this has nearly zero overhead. However, failing to do this, we will\u001b[39;00m\n\u001b[1;32m    348\u001b[0m   \u001b[39m# resolve the input arguments dynamically and only when needed.\u001b[39;00m\n",
      "File \u001b[0;32m~/my-env/lib/python3.9/site-packages/tensorflow_probability/python/distributions/deterministic.py:92\u001b[0m, in \u001b[0;36m_BaseDeterministic.__init__\u001b[0;34m(self, loc, atol, rtol, is_vector, validate_args, allow_nan_stats, parameters, name)\u001b[0m\n\u001b[1;32m     55\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Initialize a batch of `_BaseDeterministic` distributions.\u001b[39;00m\n\u001b[1;32m     56\u001b[0m \n\u001b[1;32m     57\u001b[0m \u001b[39mThe `atol` and `rtol` parameters allow for some slack in `pmf`, `cdf`\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     89\u001b[0m \u001b[39m  ValueError:  If `loc` is a scalar.\u001b[39;00m\n\u001b[1;32m     90\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m     91\u001b[0m \u001b[39mwith\u001b[39;00m tf\u001b[39m.\u001b[39mname_scope(name) \u001b[39mas\u001b[39;00m name:\n\u001b[0;32m---> 92\u001b[0m   dtype \u001b[39m=\u001b[39m dtype_util\u001b[39m.\u001b[39;49mcommon_dtype([loc, atol, rtol], dtype_hint\u001b[39m=\u001b[39;49mtf\u001b[39m.\u001b[39;49mfloat32)\n\u001b[1;32m     93\u001b[0m   \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_loc \u001b[39m=\u001b[39m tensor_util\u001b[39m.\u001b[39mconvert_nonref_to_tensor(\n\u001b[1;32m     94\u001b[0m       loc, dtype_hint\u001b[39m=\u001b[39mdtype, name\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mloc\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m     95\u001b[0m   \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_atol \u001b[39m=\u001b[39m tensor_util\u001b[39m.\u001b[39mconvert_nonref_to_tensor(\n\u001b[1;32m     96\u001b[0m       \u001b[39m0\u001b[39m \u001b[39mif\u001b[39;00m atol \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39melse\u001b[39;00m atol, dtype\u001b[39m=\u001b[39mdtype, name\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39matol\u001b[39m\u001b[39m'\u001b[39m)\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "def test(policy, test_env, num_episodes: int=10000):\n",
    "    rewards = []\n",
    "    log_interval = 100\n",
    "    time_step = test_env.reset()\n",
    "    total_return = 0.0\n",
    "    for i in tqdm(range(10000)):\n",
    "        policy_state = policy.action(time_step)\n",
    "        time_step = test_env.step(policy_state.action)\n",
    "        reward = time_step.reward.numpy()[0]\n",
    "        total_return += reward # Calculate a sum of rewards\n",
    "\n",
    "        if i % log_interval == 0:\n",
    "            # avg_return = compute_avg_return(eval_env, agent.policy, 10)\n",
    "            avg_return = total_return / eval_interval\n",
    "            print('step = {0}: Average reward = {1:.5f}'.format(step, avg_return))\n",
    "            rewards.append(avg_return)\n",
    "            total_return = 0.0 # reset\n",
    "    return rewards\n",
    "\n",
    "# The whole set of objects should be recreated \n",
    "# the same way as when the checkpoint was created.\n",
    "# train_checkpointer.initialize_or_restore()\n",
    "# global_step = tf.compat.v1.train.get_global_step()\n",
    "\n",
    "# Also save policy and export to a location\n",
    "# tf_policy_saver.save(policy_dir)\n",
    "\n",
    "# The policy can be loaded without having any knowledge \n",
    "# of what agent or network was used to create it. \n",
    "# This makes deployment of the policy much easier.\n",
    "# Load the saved policy and check how it performs.\n",
    "# saved_policy = tf.saved_model.load(policy_dir)\n",
    "test(agent.policy, test_env)\n",
    "# print(reward)\n",
    "\n",
    "# saved_res = compute_avg_return(eval_env, saved_policy, num_episodes=20)\n",
    "# random_res = compute_avg_return(eval_env, random_policy, num_episodes=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.saved_model.load.Loader._recreate_base_user_object.<locals>._UserObject at 0x22788bdaeb0>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'_UserObject' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[15], line 4\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[39m# eval_env.reset()\u001b[39;00m\n\u001b[0;32m      3\u001b[0m state \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray([[\u001b[39m6423576576\u001b[39m, \u001b[39m402653184\u001b[39m], \u001b[39m0.00578\u001b[39m], dtype\u001b[39m=\u001b[39m\u001b[39mobject\u001b[39m)\n\u001b[1;32m----> 4\u001b[0m saved_policy[state]\n\u001b[0;32m      5\u001b[0m \u001b[39m# q_values = saved_policy.\u001b[39;00m\n",
      "\u001b[1;31mTypeError\u001b[0m: '_UserObject' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "# eval_env.reset()\n",
    "\n",
    "state = np.array([[6423576576, 402653184], 0.00578], dtype=object)\n",
    "saved_policy[state]\n",
    "# q_values = saved_policy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'method' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[11], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m eval_env\u001b[39m.\u001b[39;49mcurrent_time_step[\u001b[39m'\u001b[39;49m\u001b[39mobservation\u001b[39;49m\u001b[39m'\u001b[39;49m]\n",
      "\u001b[1;31mTypeError\u001b[0m: 'method' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "time_step = eval_env.current_time_step['observation']"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Keras-rl2 DQNAgent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Vsr3tDNyUB-H"
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "print(tf.__version__)\n",
    "from keras import __version__\n",
    "tf.keras.__version__ = __version__\n",
    "\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Flatten\n",
    "# from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.optimizers.legacy import Adam\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from rl.agents import DQNAgent\n",
    "from rl.policy import BoltzmannQPolicy, EpsGreedyQPolicy\n",
    "from rl.memory import SequentialMemory\n",
    "from rl.callbacks import ModelIntervalCheckpoint, FileLogger\n",
    "\n",
    "\n",
    "def build_model(states, actions):\n",
    "    model = Sequential()\n",
    "    model.add(Flatten(input_shape=(1, 2)))\n",
    "    model.add(Dense(24, activation='relu', input_shape=states))\n",
    "    model.add(Dense(24, activation='relu'))\n",
    "    model.add(Dense(actions, activation='linear'))\n",
    "    # model.add(Flatten())\n",
    "    return model\n",
    "    \n",
    "def build_callbacks(env_name):\n",
    "    checkpoint_weights_filename = 'dqn_' + env_name + '_weights_{step}.h5f'\n",
    "    log_filename = 'dqn_{}_log.json'.format(env_name)\n",
    "    callbacks = [ModelIntervalCheckpoint(checkpoint_weights_filename, interval=5000)]\n",
    "    callbacks += [FileLogger(log_filename, interval=100)]\n",
    "    return callbacks\n",
    "\n",
    "def build_agent(model, actions):\n",
    "    policy = BoltzmannQPolicy()\n",
    "    memory = SequentialMemory(limit=50000, window_length=1)\n",
    "    dqn = DQNAgent(model=model, memory=memory, policy=policy,\n",
    "                  nb_actions=actions, nb_steps_warmup=10, target_model_update=1e-2)\n",
    "    return dqn\n",
    "\n",
    "LEARNING_RATE = 0.1\n",
    "GAMMA = 0.9999\n",
    "\n",
    "callbacks = build_callbacks(\"gc\")\n",
    "\n",
    "# policy = BoltzmannQPolicy()\n",
    "policy = EpsGreedyQPolicy()\n",
    "# memory = SequentialMemory(limit=50000, window_length=1)\n",
    "\n",
    "# memory can help a model during training\n",
    "# for this, we only consider a single malware sample (window_length=1) for each \"experience\"\n",
    "memory = SequentialMemory(limit=50000, window_length=1)\n",
    "\n",
    "# DQN agent as described in Mnih (2013) and Mnih (2015).\n",
    "# http://arxiv.org/pdf/1312.5602.pdf\n",
    "# http://arxiv.org/abs/1509.06461\n",
    "dqn = DQNAgent(\n",
    "    model=model, \n",
    "    memory=memory, \n",
    "    policy=policy,\n",
    "    nb_actions=actions, \n",
    "    nb_steps_warmup=10, \n",
    "    target_model_update=1e-2, \n",
    "    batch_size=16,\n",
    "    gamma=GAMMA\n",
    ")\n",
    "\n",
    "# keras-rl allows one to use and built-in keras optimizer\n",
    "dqn.compile(Adam(lr=LEARNING_RATE), metrics=['mae'])\n",
    "\n",
    "history = dqn.fit(env, nb_max_episode_steps=100, nb_steps=50000, visualize=False, verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7f1c41bc40>]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt \n",
    "plt.grid(True)\n",
    "plt.plot(history.history['episode_reward'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ccv83C6KUSzB"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing for 100 episodes ...\n",
      "Episode 1: reward: -200.000, steps: 200\n",
      "Episode 2: reward: -198.000, steps: 200\n",
      "Episode 3: reward: -200.000, steps: 200\n",
      "Episode 4: reward: -200.000, steps: 200\n",
      "Episode 5: reward: -196.000, steps: 200\n",
      "Episode 6: reward: -198.000, steps: 200\n",
      "Episode 7: reward: -198.000, steps: 200\n",
      "Episode 8: reward: -200.000, steps: 200\n",
      "Episode 9: reward: -198.000, steps: 200\n",
      "Episode 10: reward: -198.000, steps: 200\n",
      "Episode 11: reward: -196.000, steps: 200\n",
      "Episode 12: reward: -198.000, steps: 200\n",
      "Episode 13: reward: -198.000, steps: 200\n",
      "Episode 14: reward: -198.000, steps: 200\n",
      "Episode 15: reward: -198.000, steps: 200\n",
      "Episode 16: reward: -200.000, steps: 200\n",
      "Episode 17: reward: -200.000, steps: 200\n",
      "Episode 18: reward: -200.000, steps: 200\n",
      "Episode 19: reward: -198.000, steps: 200\n",
      "Episode 20: reward: -200.000, steps: 200\n",
      "Episode 21: reward: -200.000, steps: 200\n",
      "Episode 22: reward: -198.000, steps: 200\n",
      "Episode 23: reward: -198.000, steps: 200\n",
      "Episode 24: reward: -200.000, steps: 200\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[6], line 10\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[39m# scores = dqn.test(env, nb_episodes=100, visualize=False)\u001b[39;00m\n\u001b[1;32m      2\u001b[0m \n\u001b[1;32m      3\u001b[0m \u001b[39m# scores = dqn.test(\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[39m#     verbose=1\u001b[39;00m\n\u001b[1;32m      8\u001b[0m \u001b[39m# )\u001b[39;00m\n\u001b[0;32m---> 10\u001b[0m scores \u001b[39m=\u001b[39m dqn\u001b[39m.\u001b[39;49mtest(\n\u001b[1;32m     11\u001b[0m     env,\n\u001b[1;32m     12\u001b[0m     nb_episodes\u001b[39m=\u001b[39;49m\u001b[39m100\u001b[39;49m,\n\u001b[1;32m     13\u001b[0m     action_repetition\u001b[39m=\u001b[39;49m\u001b[39m1\u001b[39;49m,\n\u001b[1;32m     14\u001b[0m     nb_max_episode_steps\u001b[39m=\u001b[39;49m\u001b[39m200\u001b[39;49m,\n\u001b[1;32m     15\u001b[0m     visualize\u001b[39m=\u001b[39;49m\u001b[39mFalse\u001b[39;49;00m,\n\u001b[1;32m     16\u001b[0m     verbose\u001b[39m=\u001b[39;49m\u001b[39m1\u001b[39;49m\n\u001b[1;32m     17\u001b[0m )\n\u001b[1;32m     19\u001b[0m \u001b[39m# print(np.mean(scores.history['episode_reward']))\u001b[39;00m\n",
      "File \u001b[0;32m~/projects/gc-ml/gc-ml-env/lib/python3.8/site-packages/rl/core.py:348\u001b[0m, in \u001b[0;36mAgent.test\u001b[0;34m(self, env, nb_episodes, action_repetition, callbacks, visualize, nb_max_episode_steps, nb_max_start_steps, start_step_policy, verbose)\u001b[0m\n\u001b[1;32m    346\u001b[0m \u001b[39mfor\u001b[39;00m _ \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(action_repetition):\n\u001b[1;32m    347\u001b[0m     callbacks\u001b[39m.\u001b[39mon_action_begin(action)\n\u001b[0;32m--> 348\u001b[0m     observation, r, d, info \u001b[39m=\u001b[39m env\u001b[39m.\u001b[39;49mstep(action)\n\u001b[1;32m    349\u001b[0m     observation \u001b[39m=\u001b[39m deepcopy(observation)\n\u001b[1;32m    350\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprocessor \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n",
      "File \u001b[0;32m~/projects/gc-ml/JVMEnvTest.py:133\u001b[0m, in \u001b[0;36mJVMEnvTest.step\u001b[0;34m(self, action)\u001b[0m\n\u001b[1;32m    129\u001b[0m info \u001b[39m=\u001b[39m {}\n\u001b[1;32m    130\u001b[0m \u001b[39m# info = self._get_info()\u001b[39;00m\n\u001b[1;32m    131\u001b[0m \u001b[39m# print(self._get_info())\u001b[39;00m\n\u001b[0;32m--> 133\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49max\u001b[39m.\u001b[39;49mclear()\n\u001b[1;32m    135\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mrender_mode \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mhuman\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[1;32m    136\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_render_frame()\n",
      "File \u001b[0;32m~/projects/gc-ml/gc-ml-env/lib/python3.8/site-packages/matplotlib/axes/_base.py:1480\u001b[0m, in \u001b[0;36m_AxesBase.clear\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1478\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mclear\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m   1479\u001b[0m \u001b[39m    \u001b[39m\u001b[39m\"\"\"Clear the Axes.\"\"\"\u001b[39;00m\n\u001b[0;32m-> 1480\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcla()\n",
      "File \u001b[0;32m~/projects/gc-ml/gc-ml-env/lib/python3.8/site-packages/matplotlib/axes/_base.py:1200\u001b[0m, in \u001b[0;36m_AxesBase.cla\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1197\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39myaxis\u001b[39m.\u001b[39mclear()\n\u001b[1;32m   1199\u001b[0m \u001b[39mfor\u001b[39;00m name, spine \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mspines\u001b[39m.\u001b[39mitems():\n\u001b[0;32m-> 1200\u001b[0m     spine\u001b[39m.\u001b[39;49mclear()\n\u001b[1;32m   1202\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mignore_existing_data_limits \u001b[39m=\u001b[39m \u001b[39mTrue\u001b[39;00m\n\u001b[1;32m   1203\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcallbacks \u001b[39m=\u001b[39m cbook\u001b[39m.\u001b[39mCallbackRegistry()\n",
      "File \u001b[0;32m~/projects/gc-ml/gc-ml-env/lib/python3.8/site-packages/matplotlib/spines.py:223\u001b[0m, in \u001b[0;36mSpine.clear\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    221\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_position \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m  \u001b[39m# clear position\u001b[39;00m\n\u001b[1;32m    222\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39maxis \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 223\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49maxis\u001b[39m.\u001b[39;49mclear()\n",
      "File \u001b[0;32m~/projects/gc-ml/gc-ml-env/lib/python3.8/site-packages/matplotlib/axis.py:818\u001b[0m, in \u001b[0;36mAxis.clear\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    812\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_major_tick_kw[\u001b[39m'\u001b[39m\u001b[39mgridOn\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m=\u001b[39m (\n\u001b[1;32m    813\u001b[0m         mpl\u001b[39m.\u001b[39mrcParams[\u001b[39m'\u001b[39m\u001b[39maxes.grid\u001b[39m\u001b[39m'\u001b[39m] \u001b[39mand\u001b[39;00m\n\u001b[1;32m    814\u001b[0m         mpl\u001b[39m.\u001b[39mrcParams[\u001b[39m'\u001b[39m\u001b[39maxes.grid.which\u001b[39m\u001b[39m'\u001b[39m] \u001b[39min\u001b[39;00m (\u001b[39m'\u001b[39m\u001b[39mboth\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mmajor\u001b[39m\u001b[39m'\u001b[39m))\n\u001b[1;32m    815\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_minor_tick_kw[\u001b[39m'\u001b[39m\u001b[39mgridOn\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m=\u001b[39m (\n\u001b[1;32m    816\u001b[0m         mpl\u001b[39m.\u001b[39mrcParams[\u001b[39m'\u001b[39m\u001b[39maxes.grid\u001b[39m\u001b[39m'\u001b[39m] \u001b[39mand\u001b[39;00m\n\u001b[1;32m    817\u001b[0m         mpl\u001b[39m.\u001b[39mrcParams[\u001b[39m'\u001b[39m\u001b[39maxes.grid.which\u001b[39m\u001b[39m'\u001b[39m] \u001b[39min\u001b[39;00m (\u001b[39m'\u001b[39m\u001b[39mboth\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mminor\u001b[39m\u001b[39m'\u001b[39m))\n\u001b[0;32m--> 818\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mreset_ticks()\n\u001b[1;32m    820\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mconverter \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m    821\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39munits \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n",
      "File \u001b[0;32m~/projects/gc-ml/gc-ml-env/lib/python3.8/site-packages/matplotlib/axis.py:846\u001b[0m, in \u001b[0;36mAxis.reset_ticks\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    844\u001b[0m     \u001b[39mpass\u001b[39;00m\n\u001b[1;32m    845\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 846\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mset_clip_path(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49maxes\u001b[39m.\u001b[39;49mpatch)\n\u001b[1;32m    847\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mAttributeError\u001b[39;00m:\n\u001b[1;32m    848\u001b[0m     \u001b[39mpass\u001b[39;00m\n",
      "File \u001b[0;32m~/projects/gc-ml/gc-ml-env/lib/python3.8/site-packages/matplotlib/axis.py:937\u001b[0m, in \u001b[0;36mAxis.set_clip_path\u001b[0;34m(self, clippath, transform)\u001b[0m\n\u001b[1;32m    935\u001b[0m \u001b[39msuper\u001b[39m()\u001b[39m.\u001b[39mset_clip_path(clippath, transform)\n\u001b[1;32m    936\u001b[0m \u001b[39mfor\u001b[39;00m child \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmajorTicks \u001b[39m+\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mminorTicks:\n\u001b[0;32m--> 937\u001b[0m     child\u001b[39m.\u001b[39;49mset_clip_path(clippath, transform)\n\u001b[1;32m    938\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mstale \u001b[39m=\u001b[39m \u001b[39mTrue\u001b[39;00m\n",
      "File \u001b[0;32m~/projects/gc-ml/gc-ml-env/lib/python3.8/site-packages/matplotlib/axis.py:238\u001b[0m, in \u001b[0;36mTick.set_clip_path\u001b[0;34m(self, clippath, transform)\u001b[0m\n\u001b[1;32m    236\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mset_clip_path\u001b[39m(\u001b[39mself\u001b[39m, clippath, transform\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[1;32m    237\u001b[0m     \u001b[39m# docstring inherited\u001b[39;00m\n\u001b[0;32m--> 238\u001b[0m     \u001b[39msuper\u001b[39;49m()\u001b[39m.\u001b[39;49mset_clip_path(clippath, transform)\n\u001b[1;32m    239\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mgridline\u001b[39m.\u001b[39mset_clip_path(clippath, transform)\n\u001b[1;32m    240\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mstale \u001b[39m=\u001b[39m \u001b[39mTrue\u001b[39;00m\n",
      "File \u001b[0;32m~/projects/gc-ml/gc-ml-env/lib/python3.8/site-packages/matplotlib/artist.py:791\u001b[0m, in \u001b[0;36mArtist.set_clip_path\u001b[0;34m(self, path, transform)\u001b[0m\n\u001b[1;32m    788\u001b[0m \u001b[39mif\u001b[39;00m transform \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m    789\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(path, Rectangle):\n\u001b[1;32m    790\u001b[0m         \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mclipbox \u001b[39m=\u001b[39m TransformedBbox(Bbox\u001b[39m.\u001b[39munit(),\n\u001b[0;32m--> 791\u001b[0m                                        path\u001b[39m.\u001b[39;49mget_transform())\n\u001b[1;32m    792\u001b[0m         \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_clippath \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m    793\u001b[0m         success \u001b[39m=\u001b[39m \u001b[39mTrue\u001b[39;00m\n",
      "File \u001b[0;32m~/projects/gc-ml/gc-ml-env/lib/python3.8/site-packages/matplotlib/patches.py:278\u001b[0m, in \u001b[0;36mPatch.get_transform\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    276\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_transform\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m    277\u001b[0m \u001b[39m    \u001b[39m\u001b[39m\"\"\"Return the `~.transforms.Transform` applied to the `Patch`.\"\"\"\u001b[39;00m\n\u001b[0;32m--> 278\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mget_patch_transform() \u001b[39m+\u001b[39m artist\u001b[39m.\u001b[39mArtist\u001b[39m.\u001b[39mget_transform(\u001b[39mself\u001b[39m)\n",
      "File \u001b[0;32m~/projects/gc-ml/gc-ml-env/lib/python3.8/site-packages/matplotlib/patches.py:758\u001b[0m, in \u001b[0;36mRectangle.get_patch_transform\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    753\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_patch_transform\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m    754\u001b[0m     \u001b[39m# Note: This cannot be called until after this has been added to\u001b[39;00m\n\u001b[1;32m    755\u001b[0m     \u001b[39m# an Axes, otherwise unit conversion will fail. This makes it very\u001b[39;00m\n\u001b[1;32m    756\u001b[0m     \u001b[39m# important to call the accessor method and not directly access the\u001b[39;00m\n\u001b[1;32m    757\u001b[0m     \u001b[39m# transformation member variable.\u001b[39;00m\n\u001b[0;32m--> 758\u001b[0m     bbox \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mget_bbox()\n\u001b[1;32m    759\u001b[0m     \u001b[39mreturn\u001b[39;00m (transforms\u001b[39m.\u001b[39mBboxTransformTo(bbox)\n\u001b[1;32m    760\u001b[0m             \u001b[39m+\u001b[39m transforms\u001b[39m.\u001b[39mAffine2D()\u001b[39m.\u001b[39mrotate_deg_around(\n\u001b[1;32m    761\u001b[0m                 bbox\u001b[39m.\u001b[39mx0, bbox\u001b[39m.\u001b[39my0, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mangle))\n",
      "File \u001b[0;32m~/projects/gc-ml/gc-ml-env/lib/python3.8/site-packages/matplotlib/patches.py:851\u001b[0m, in \u001b[0;36mRectangle.get_bbox\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    849\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Return the `.Bbox`.\"\"\"\u001b[39;00m\n\u001b[1;32m    850\u001b[0m x0, y0, x1, y1 \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_convert_units()\n\u001b[0;32m--> 851\u001b[0m \u001b[39mreturn\u001b[39;00m transforms\u001b[39m.\u001b[39;49mBbox\u001b[39m.\u001b[39mfrom_extents(x0, y0, x1, y1)\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# scores = dqn.test(env, nb_episodes=100, visualize=False)\n",
    "\n",
    "# scores = dqn.test(\n",
    "#     env, \n",
    "#     nb_episodes=1,\n",
    "#     visualize=False, \n",
    "#     verbose=1\n",
    "# )\n",
    "\n",
    "scores = dqn.test(\n",
    "    env,\n",
    "    nb_episodes=100,\n",
    "    action_repetition=1,\n",
    "    nb_max_episode_steps=200,\n",
    "    visualize=False,\n",
    "    verbose=1\n",
    ")\n",
    "\n",
    "# print(np.mean(scores.history['episode_reward']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f07c01c9e80>]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt \n",
    "plt.plot(scores.history['episode_reward'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mW3VSmX-UT5m"
   },
   "outputs": [],
   "source": [
    "_ = dqn.test(env, nb_episodes=15, visualize=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DONE\n",
      "{'agent': array([  2., -19.]), 'target': array([  1.99999998, -19.        ])}\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkcAAAHHCAYAAAC1G/yyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABux0lEQVR4nO3dd3hT1f8H8HfSNuledEN3oayyCpQyZEqZMgRRkCUqIqA/xQEuROWLiooKCDgAFZShKIrspbKhQIFCCy0dQHcLHXQmOb8/SmNLSwe0vRnv1/Pk0dzc3Lxvb0I+uefcc2RCCAEiIiIiAgDIpQ5AREREpEtYHBERERGVw+KIiIiIqBwWR0RERETlsDgiIiIiKofFEREREVE5LI6IiIiIymFxRERERFQOiyMiIiKiclgcEZHk3n33XchkMqljUD3z8fHBlClTJHnt+Ph4yGQyrF27VpLXJ/3G4oiM2ldffQWZTIaQkBCpo1Tpq6++qtM/7jKZDLNmzWq4QAbs4MGDGD16NNzc3KBQKODi4oLhw4djy5YtUke7L2vXroVMJoO5uTlu3LhR6fE+ffqgbdu2EiSrXz/99BM+//xzqWOQgWFxREZt/fr18PHxwYkTJxATEyN1nErqWhzpq7feegsFBQWSvf78+fPRt29fXLhwAdOnT8fKlSvx6quvIi8vD48++ih++uknybI9qKKiInz44YeSvHZ0dDS++eabBn2NexVH3t7eKCgowMSJExv09ckwsTgioxUXF4cjR47gs88+g7OzM9avXy91JIORn59fp/VNTU1hbm7eQGmq98svv+C9997DmDFjEBkZiQULFuCpp57Cq6++igMHDmDnzp2wtbWtl9eq69+lPnTo0AHffPMNkpKSGv21lUolzMzMGv11AWjPmpmYmEjy+qTfWByR0Vq/fj0cHBwwdOhQjBkz5p7FUWZmJiZOnAhbW1vY29tj8uTJiIiIqLI/Q1RUFMaMGQNHR0eYm5ujc+fO+OOPPyqsU9bccfjwYbz88stwdnaGlZUVRo0ahfT0dO16Pj4+iIyMxN9//w2ZTAaZTIY+ffo88H5rNBp8/vnnaNOmDczNzeHq6orp06fj5s2bFdbbunUrhg4dCg8PDyiVSvj7++P999+HWq2usF5Z80x4eDgeeughWFpa4o033tD2+fjkk0/w9ddfw9/fH0qlEl26dMHJkycrbKOqPkdlTYS///472rZtC6VSiTZt2mDnzp2V9ungwYPo3LkzzM3N4e/vj1WrVtW6H9Pbb78NR0dHrF69usov8rCwMAwbNgzAf8cuPj6+0uvLZDIcPHiwxr/LsGHD4OfnV2WW0NBQdO7cucKydevWITg4GBYWFnB0dMTjjz+Oa9eu1bhfZd544w2o1epanT1as2YN+vXrBxcXFyiVSrRu3RorVqyosE5d8lfV5+jcuXPo3bs3LCws0KxZM3zwwQdYs2ZNpb9rbd5/ffr0wV9//YWEhATtZ8THxwfAvfsc7d+/H7169YKVlRXs7e0xYsQIXLp0qcI6Ze+dmJgYTJkyBfb29rCzs8PUqVMlKXCp8ZlKHYBIKuvXr8fo0aOhUCjwxBNPYMWKFTh58iS6dOmiXUej0WD48OE4ceIEZsyYgZYtW2Lr1q2YPHlype1FRkaiR48eaNq0KebOnQsrKyts2rQJI0eOxK+//opRo0ZVWH/27NlwcHDA/PnzER8fj88//xyzZs3Cxo0bAQCff/45Zs+eDWtra7z55psAAFdX1wfe7+nTp2Pt2rWYOnUqXnjhBcTFxWHZsmU4c+YMDh8+rC0Q1q5dC2tra7z88suwtrbG/v378c477yAnJweLFy+usM3MzEwMHjwYjz/+OJ588skKOX/66Sfk5uZi+vTpkMlk+PjjjzF69GhcvXq1xrMKhw4dwpYtW/D888/DxsYGX375JR599FEkJiaiSZMmAIAzZ85g0KBBcHd3x4IFC6BWq/Hee+/B2dm5xr/FlStXEBUVhaeeego2NjZ1/VPWqKq/S3BwMCZNmlTpvZaQkIBjx45V+NsuXLgQb7/9Nh577DE8/fTTSE9Px9KlS/HQQw/hzJkzsLe3rzGDr68vJk2ahG+++QZz586Fh4fHPdddsWIF2rRpg0ceeQSmpqb4888/8fzzz0Oj0WDmzJkAgHHjxtU6/91u3LiBvn37QiaTYd68ebCyssK3334LpVJZad3avP/efPNNZGdn4/r161iyZAkAwNra+p6vv3fvXgwePBh+fn549913UVBQgKVLl6JHjx44ffq0trAq89hjj8HX1xeLFi3C6dOn8e2338LFxQUfffTRPV+DDIQgMkKnTp0SAMSePXuEEEJoNBrRrFkz8eKLL1ZY79dffxUAxOeff65dplarRb9+/QQAsWbNGu3y/v37i6CgIFFYWKhdptFoRPfu3UXz5s21y9asWSMAiAEDBgiNRqNd/tJLLwkTExNx69Yt7bI2bdqI3r1713q/AIiZM2fe8/F///1XABDr16+vsHznzp2Vlufn51d6/vTp04WlpWWFfezdu7cAIFauXFlh3bi4OAFANGnSRGRlZWmXb926VQAQf/75p3bZ/Pnzxd3/HAEQCoVCxMTEaJdFREQIAGLp0qXaZcOHDxeWlpbixo0b2mVXrlwRpqamlbZ5t7IsS5YsqXa9MmXHLi4ursLyAwcOCADiwIED2mX3+rtkZ2cLpVIp5syZU2H5xx9/LGQymUhISBBCCBEfHy9MTEzEwoULK6x3/vx5YWpqWmn5vbKePHlSxMbGClNTU/HCCy9UyNemTZsKz6nqmIeFhQk/P7865xdCCG9vbzF58mTt/dmzZwuZTCbOnDmjXZaZmSkcHR0r/V1r+/4bOnSo8Pb2rrRu2fuv/Ge0Q4cOwsXFRWRmZmqXRURECLlcLiZNmqRdVvZ+fOqppypsc9SoUaJJkyaVXosMD5vVyCitX78erq6u6Nu3L4DSJpxx48Zhw4YNFU7b79y5E2ZmZnjmmWe0y+RyufZXdJmsrCzs378fjz32GHJzc5GRkYGMjAxkZmYiLCwMV65cqXTF0LPPPluh2adXr15Qq9VISEhoiF0GAGzevBl2dnZ4+OGHtRkzMjIQHBwMa2trHDhwQLuuhYWF9v/L9qlXr17Iz89HVFRUhe0qlUpMnTq1ytccN24cHBwctPd79eoFALh69WqNeQcMGAB/f3/t/Xbt2sHW1lb7XLVajb1792LkyJEVzogEBARg8ODBNW4/JycHABrkrBFQ9d/F1tYWgwcPxqZNmyCE0C7fuHEjunXrBi8vLwDAli1boNFo8Nhjj1U4Vm5ubmjevHmFY1UTPz8/TJw4EV9//TWSk5PvuV75Y56dnY2MjAz07t0bV69eRXZ2dp3yV2Xnzp0IDQ1Fhw4dtMscHR0xYcKEarPU9P6rjeTkZJw9exZTpkyBo6Ojdnm7du3w8MMPY/v27ZWe89xzz1W436tXL2RmZmrfN2S4WByR0VGr1diwYQP69u2LuLg4xMTEICYmBiEhIUhNTcW+ffu06yYkJMDd3R2WlpYVthEQEFDhfkxMDIQQePvtt+Hs7FzhNn/+fABAWlpahefc/SVSVkDc3fenPl25cgXZ2dlwcXGplDMvL69CxsjISIwaNQp2dnawtbWFs7MznnzySQDQflGWadq0KRQKRZWv+SD7WdUXrYODg/a5aWlpKCgoqHQ8gMrHqCplHa1zc3NrXPd+3OvvMm7cOFy7dg1Hjx4FAMTGxiI8PBzjxo3TrnPlyhUIIdC8efNKx+rSpUuV3k81eeutt6BSqarte3T48GEMGDBA2x/H2dkZb7zxBoCKx7w2+auSkJBQ62NVl/dfbZT96AgMDKz0WKtWrZCRkYHbt29XWC7FZ5R0A/sckdHZv38/kpOTsWHDBmzYsKHS4+vXr8fAgQPrtE2NRgMAeOWVVxAWFlblOnd/AdzrKpryv8brm0ajgYuLyz07n5f107l16xZ69+4NW1tbvPfee/D394e5uTlOnz6N119/Xbu/Zcr/yr/bg+xnQ/+NWrZsCQA4f/58rda/Vwfvuzupl7nX32X48OGwtLTEpk2b0L17d2zatAlyuRxjx47VrqPRaCCTybBjx44q/w7V9a2pip+fH5588kl8/fXXmDt3bqXHY2Nj0b9/f7Rs2RKfffYZPD09oVAosH37dixZsqTCMa9N/gdR1/dfQ5HiM0q6gcURGZ3169fDxcUFy5cvr/TYli1b8Ntvv2HlypWwsLCAt7c3Dhw4gPz8/Apnj+4eE6ns6h0zMzMMGDCg3rLW96jR/v7+2Lt3L3r06FFtQXPw4EFkZmZiy5YteOihh7TL4+Li6jXPg3JxcYG5uXmVY1TVZtyqFi1aIDAwEFu3bsUXX3xRY8FRdubg1q1bFZbXtSnUysoKw4YNw+bNm/HZZ59h48aN6NWrV4WmQX9/fwgh4OvrixYtWtRp+/fy1ltvYd26dVV2KP7zzz9RVFSEP/74o8IZk6qa72qTvyre3t61OlZ1ef/V9jPi7e0NoHTspbtFRUXByckJVlZWtdoWGT42q5FRKSgowJYtWzBs2DCMGTOm0m3WrFnIzc3VXn4fFhaGkpKSCgPZaTSaSoWVi4sL+vTpg1WrVlXZp6P8Jfp1YWVlVemL+EE89thjUKvVeP/99ys9plKptK9V9ou5/C/k4uJifPXVV/WWpT6YmJhgwIAB+P333yuM4xMTE4MdO3bUahsLFixAZmYmnn76aahUqkqP7969G9u2bQMAbf+nf/75R/u4Wq3G119/Xefs48aNQ1JSEr799ltERERUapIaPXo0TExMsGDBgkpnKoQQyMzMrPNr+vv748knn8SqVauQkpJS4bGqjnl2djbWrFlzX/mrEhYWhqNHj+Ls2bPaZVlZWZXOZNbl/WdlZVWrZjZ3d3d06NAB33//fYXP1IULF7B7924MGTKkxm2Q8eCZIzIqf/zxB3Jzc/HII49U+Xi3bt20A0KOGzcOI0eORNeuXTFnzhzExMSgZcuW+OOPP5CVlQWg4q/W5cuXo2fPnggKCsIzzzwDPz8/pKam4ujRo7h+/ToiIiLqnDc4OBgrVqzABx98gICAALi4uKBfv37VPufUqVP44IMPKi3v06cPevfujenTp2PRokU4e/YsBg4cCDMzM1y5cgWbN2/GF198gTFjxqB79+5wcHDA5MmT8cILL0Amk+HHH3/UyeaEd999F7t370aPHj0wY8YMqNVqLFu2DG3btq3wJXwv48aNw/nz57Fw4UKcOXMGTzzxBLy9vZGZmYmdO3di37592hGy27Rpg27dumHevHnIysqCo6MjNmzYUGVRVZMhQ4bAxsYGr7zyCkxMTPDoo49WeNzf3x8ffPAB5s2bh/j4eIwcORI2NjaIi4vDb7/9hmeffRavvPJKnV/3zTffxI8//ojo6Gi0adNGu3zgwIFQKBQYPnw4pk+fjry8PHzzzTdwcXGpsuCvKX9VXnvtNaxbtw4PP/wwZs+erb2U38vLC1lZWdrPU13ef8HBwdi4cSNefvlldOnSBdbW1hg+fHiVr7948WIMHjwYoaGhmDZtmvZSfjs7O7z77ru1/AuSUWj8C+SIpDN8+HBhbm4ubt++fc91pkyZIszMzERGRoYQQoj09HQxfvx4YWNjI+zs7MSUKVPE4cOHBQCxYcOGCs+NjY0VkyZNEm5ubsLMzEw0bdpUDBs2TPzyyy/adcpfYl1eVZeDp6SkiKFDhwobGxsBoMbL+gHc8/b+++9r1/v6669FcHCwsLCwEDY2NiIoKEi89tprIikpSbvO4cOHRbdu3YSFhYXw8PAQr732mti1a1eVl6zffUm4EP9dSr148eIqc86fP197/16X8lc1LMHdl4cLIcS+fftEx44dhUKhEP7+/uLbb78Vc+bMEebm5tX+ve7exogRI4SLi4swNTUVzs7OYvjw4WLr1q0V1ouNjRUDBgwQSqVSuLq6ijfeeEPs2bOn1n+X8iZMmKAd1uFefv31V9GzZ09hZWUlrKysRMuWLcXMmTNFdHR0tdu+1/tMCCEmT54sAFTK98cff4h27doJc3Nz4ePjIz766COxevXqKocvqE3+qo7VmTNnRK9evYRSqRTNmjUTixYtEl9++aUAIFJSUrTr1fb9l5eXJ8aPHy/s7e0FAO1l/VVdyi+EEHv37hU9evQQFhYWwtbWVgwfPlxcvHixwjpl78f09PQq/6ZV/S3IsMiE0MGfgkQ67vfff8eoUaNw6NAh9OjRQ+o4VIWRI0ciMjISV65ckToK1eD//u//sGrVKuTl5XG6D9IJ7HNEVIO7J0RVq9VYunQpbG1t0alTJ4lSUXl3H6MrV65g+/bt9TLdCtWvu49VZmYmfvzxR/Ts2ZOFEekM9jkiqsHs2bNRUFCA0NBQFBUVYcuWLThy5Aj+97//VXvFFzUePz8/TJkyBX5+fkhISMCKFSugUCjw2muvSR2N7hIaGoo+ffqgVatWSE1NxXfffYecnBy8/fbbUkcj0mJxRFSDfv364dNPP8W2bdtQWFiIgIAALF26FLNmzZI6Gt0xaNAg/Pzzz0hJSYFSqURoaCj+97//oXnz5lJHo7sMGTIEv/zyC77++mvIZDJ06tQJ3333XYVL9omkxj5HREREROWwzxERERFROSyOiIiIiMphn6M60mg0SEpKgo2NTb1P7UBEREQNQwiB3NxceHh4QC6v/twQi6M6SkpKgqenp9QxiIiI6D5cu3YNzZo1q3YdFkd1ZGNjA6D0j2traytxGiIiIqqNnJwceHp6ar/Hq8PiqI7KmtJsbW1ZHBEREemZ2nSJYYdsIiIionJYHBERERGVw+KIiIiIqBz2OSIiIr2nVqtRUlIidQySmEKhqPEy/dpgcURERHpLCIGUlBTcunVL6iikA+RyOXx9faFQKB5oOyyOiIhIb5UVRi4uLrC0tOTgvEasbJDm5ORkeHl5PdB7gcURERHpJbVarS2MmjRpInUc0gHOzs5ISkqCSqWCmZnZfW+HHbKJiEgvlfUxsrS0lDgJ6Yqy5jS1Wv1A22FxREREeo1NaVSmvt4LLI6IiIiIyjHa4mj58uXw8fGBubk5QkJCcOLECakjERERGY1jx47B2toaLi4uuHz5stRxKjDK4mjjxo14+eWXMX/+fJw+fRrt27dHWFgY0tLSpI5GRERGICUlBbNnz4afnx+USiU8PT0xfPhw7Nu3T+pojSIyMhJDhgzB1KlT0atXLwwcOBA3btyosE5WVhZmz56NwMBAWFhYwMvLCy+88AKys7MbPJ9RFkefffYZnnnmGUydOhWtW7fGypUrYWlpidWrV0sdjYiIDFx8fDyCg4Oxf/9+LF68GOfPn8fOnTvRt29fzJw58763K4SASqWqx6QNIz4+HgMHDsRzzz2HpUuXYtOmTdoCKSsrS7teUlISkpKS8Mknn+DChQtYu3Ytdu7ciWnTpjV4RpkQQjT4q+iQ4uJiWFpa4pdffsHIkSO1yydPnoxbt25h69atFdYvKipCUVGR9n5OTg48PT2RnZ0NW1vbxopNRA+gsESNlOxCJGUXICW7EMnZhcjMK8btIhXyilXIS05Dfmw8UFgImRCQCwG5sxMUgS1gb62EnYVZ6c1SAXc7c3g6WKKZgwXsLc3YGVhChYWFiIuLg6+vL8zNzaWOU2tDhgzBuXPnEB0dDSsrqwqP3bp1C/b29oiPj4evry/OnDmDDh06aB9zcHDAgQMH0KdPHxw8eBB9+/bF9u3b8dZbb+H8+fNYtmwZpk+fjkuXLqFly5ba7S5ZsgTLli1DbGwsAODChQt49dVX8e+//8LKygoDBw7EkiVL4OTkdN/7FRUVhU6dOuHbb7/F+PHjAQCbNm3C5MmTER4ejtatWyMtLQ09e/bElClT8MYbb2ifq9Fo8PzzzyMiIgL79u275xWImzdvxpNPPonbt2/D1LTyaETVvSdycnJgZ2dXq+9voxvnKCMjA2q1Gq6urhWWu7q6IioqqtL6ixYtwoIFCxorHhE9ACEEYtNvIzIpG1dS8xCdmovLqblIzMpHjT8DbT2Bu/+9jMms9inWSlN4OVqitYctWrvbopV76X/tLO9/fBW6f0IIFJQ82CXc98vCzKRWhXJWVhZ27tyJhQsXViqMAMDe3r7Orz137lx88skn8PPzg4ODA7755husX78e77//vnad9evXawuWW7duoV+/fnj66aexZMkSFBQU4PXXX8djjz2G/fv3AwDWrl2LqVOnoi7nT1q2bIlPPvkEzz//PHr27Am5XI7nnnsOH330EVq3bg0A9+xfJJfLsXLlyhpfo6ywqaowqk9GVxzV1bx58/Dyyy9r75edOSIi6ZWoNYi4dgsn428iPCEL4Qk3cTO/6vm1zM3k8LCzgLu9OdztLNDEWgEbpSmslKawMpPDKjMN8qwsaNRqaJTm0Lh7oMjCCtkFJdrbzfxi3LhVgOs3C5CeW4S8IhUuJufgYnJOhdfyd7ZCiF8ThPg6optfE7ja6s9ZDX1WUKJG63d2SfLaF98Lg6Wi5q/UmJgYCCEqnNV5UO+99x4efvhh7f0JEyZg2bJl2uLo8uXLCA8Px7p16wAAy5YtQ8eOHfG///1P+5zVq1fD09MTly9fRosWLWBnZ4fAwMA6Z3n++eexfft2PPnkk1AoFOjSpQtmz579gHtYKiMjA++//z6effbZetledYyuOHJycoKJiQlSU1MrLE9NTYWbm1ul9ZVKJZRKZWPFI6IapOcW4WB0Gg5Gp+OfK+nILazYx0JpKkcbD1sEutki0NUaLdxs0MLVBk2sFDX8sveuU47CEjWu38xHbPptXEwqLZAuJuXgxq0CxKbfRmz6bfx0PBEA4OdshQGtXDGglSuCvR1gImdTnLFqiJ4snTt3rnD/8ccfxyuvvIJjx46hW7duWL9+PTp16qQtyCIiInDgwAFYW1tX2lZsbCxatGiBUaNGYdSoUfd8zfXr12P69Ona+zt27ECvXr0AlBZaLVq0gFwuR2RkZL00Pefk5GDo0KFo3bo13n333QfeXk2MrjhSKBQIDg7Gvn37tH2ONBoN9u3bh1mzZkkbjoiqlJZbiL/OJeOPiCScSbxV4TEHSzOE+DZBZx8HBHs7oI2HHRSmDX+tibmZCQJcbBDgYoOwNv/9sLp5uxgn47NwPC4Lx65m4mJyDq6m38bX6Vfx9T9X4WBphn4tXTG0nRt6NXeGmYlRXhfTICzMTHDxvTDJXrs2mjdvDplMVmU3jvLKZpYvX0yVjQh+t7ub59zc3NCvXz/89NNP6NatG3766SfMmDFD+3heXh6GDx+Ojz76qNK23N3da7UfjzzyCEJCQrT3mzZtqv3/iIgI3L59G3K5HMnJybXe5r3k5uZi0KBBsLGxwW+//fZA04LUltEVRwDw8ssvY/LkyejcuTO6du2Kzz//HLdv38bUqVOljkZEd9wuUmH7+dKC6HBMBjTlfnAHNbVD30Bn9G3pgnbN7HXqTIyDlQID27hh4J2CKbugBIdjMrDnYir2R6XhZn4Jfj19Hb+evg4nawWGt/fAo52aoY2HLTt3PyCZTFarpi0pOTo6IiwsDMuXL8cLL7xwzw7Zzs7OAIDk5GR07NgRAHD27Nlav86ECRPw2muv4YknnsDVq1fx+OOPax/r1KkTfv31V/j4+Nx33x0bGxvY2NhUWp6VlYUpU6bgzTffRHJyMiZMmIDTp0/DwsLivl4nJycHYWFhUCqV+OOPPxqt473RXa1WZtmyZVi8eDFSUlLQoUMHfPnllxWq4HupS293Iqq76JRcrDuWgN/O3EBe0X9NZh297DGivQeGBLnDRU/78KjUGpxKuImdF1Kw7VwSMvKKtY+1cLXGxG7eGN2pGayUuv0Fryv09Wq1q1evokePHnB0dMR7772Hdu3aQaVSYc+ePVixYgUuXboEAAgNDYWZmRlWrVqFtLQ0vPbaazhx4kSlq9Vu3rxZqSN3bm4uXF1d0aJFCzg5OWHv3r3ax5KSktChQwf07t0br732GhwdHRETE4MNGzbg22+/hYmJCX777TfMmzevxjNcd3vssceQmJiIQ4cOoaioCB07dsTDDz+M5cuX1/nvlJOTg4EDByI/Px+//fZbhULS2dkZJiaVz9bxarUHNGvWLDajEekIlVqD7RdS8OPReJyMv6ld7utkhUc7NcUj7ZvCq4n+Ty5qaiJHN78m6ObXBG8ObYV/r6Rjy+kb2H0xFZdT8/D21kh8vDMaYzo3w+RQH/g4Vb6aifSfn58fTp8+jYULF2LOnDlITk6Gs7MzgoODsWLFCu16q1evxrRp0xAcHIzAwEB8/PHHGDhwYK1ew8bGBsOHD8emTZsqjeHn4eGBw4cP4/XXX8fAgQNRVFQEb29vDBo0SNucl52djejo6Drt1w8//IDt27fjzJkzMDU1hampKdatW4eePXti2LBhGDx4cJ22d/r0aRw/fhwAEBAQUOGxuLg4+Pj41Gl7dWG0Z47uF88cEdWfwhI1Nodfx9f/xOJaVgEAwEQuw8DWrniymze6+zcxiqamnMIS/Bp+HT8cTUBcxm3t8odbu2JW3wC097SXLpwO09czR9RweOaIiPRWbmEJfjyWgNWH4pGRVzrIqqOVApNCvfFEVy+ju/Td1twMU3v4YnKoD/65ko7vj8Tj4OV07LmYij0XU/FQC2fM7heALj6OUkclMgosjoio0RSWqLHuWAKWH4jRjkfU1N4Czz7kh8c6e8JCUbsrfgyVXC5Dn0AX9Al0QWx6Hr46EIvfz97AP5fT8c/ldHTzc8Rrg1qik5eD1FGJDBqLIyJqcCq1BltO38Dney8jKbsQAODnZIWZfQPwSAcPXs5eBX9na3z6WHu82L85Vvwdi1/Cr+HY1SyM/uoIBrd1w6thgfBzrjxODRE9OBZHRNSg/r2SjgV/XkRMWh4AwN3OHP83oDke7dQMpiyKauTVxBKLRgdhdr8AfLH3CjaHX8OOCynYfTEVT3T1xIv9W8DZhgPVEtUnFkdE1CCuZeXjg78uYldk6Wj0DpZmmNk3AE9284Z5LQfMo/942FvgozHtMK2XLz7aEYV9UWlYdywRv5xMwsNuLdDPyxutW8pxHzM+6D1eV0Rl6uu9wOKIiOpVYYkaKw7GYuXfsShSaWAil2FyqA9eHNAcdhackPVBtXC1wXdTumDCS5nYn3UJcM/Gnzcu4tfT15G5uy02r3DAI49InbJxlI2UnJ+ff9+DDJJhKS4uHTusqjGQ6oLFERHVm2NXMzH313OIz8wHAHT3b4J3H2mDFq6VR9KlB/P29CYQ7/fApdhEZHtFQ+GaA/eJR3Awvxkeym8Fe0uF1BEbnImJCezt7ZGWlgYAsLS0NIqhH6hqGo0G6enpsLS0vO+Rv8twnKM64jhHRJXlFJbgwx1R2olW3WzN8c7w1hjc1o1fVo0gM68IH+6Iwubw6wAAZxsl/jcqCA+3dpU4WcMTQiAlJQW3bt2SOgrpALlcDl9fXygUlX8c1OX7m8VRHbE4Iqpof1Qq3thyASk5pVehTQjxwuuDW8LWnE1oje1UfBZe//UcYtNLB5Ic2cED84e3gYOV4Z9FUqvV95yYlYyHQqHQjvJ9NxZHDYjFEVGp/GIV3t92ET+fuAYA8GliiQ8fbYdufk0kTmbcCkvUWLL3Mr755yo0AnCyVmLRaOM4i0RUHRZHDYjFERFw7vot/N+Gs7iacRsyGTCthy/mDAw0+kEcdcmZxJt49Zdz2iEUJnbzxptDW/FKQTJaLI4aEIsjMmZqjcDKv2OxZM9lqDQCbrbm+Gxce3T3d5I6GlWhsESNT3dH45t/4wAAga42+PKJjgh0Ywd5Mj4sjhoQiyMyVhl5RXjh5zM4EpsJABga5I6Fo9oaxVVR+u7vy+mYsykCGXlFUJrK8daw1ngyxIud5cmosDhqQCyOyBidjM/CrJ9OIzWnCJYKEyx4pA3GBDfjl6seycgrwiubI3AwOh0AMLy9Bz4cHQQrJUd0IeNQl+9vjt1PRPckhMC3/17F418fQ2pOEQJcrPHHrB4Y29mThZGecbJWYvXkLnhraCuYymX4MyIJo746jKvpeVJHI9I5LI6IqEp5RSo8v/40PvjrEtQagUfae2DrzB4IcGF/FX0ll8vwdC8/bHi2G1xslLicmocRyw5jd2SK1NGIdAqLIyKq5FpWPsasOIIdF1JgZiLDeyPa4IvHO7AJxkB09nHEttk90dXHEblFKjz7Yzg+3R0NjYa9LIgAFkdEdJcTcVkYsfwwolJy4WStxMbpoZgU6sNmNAPjYmuO9c+EYGoPHwDA0v0xmPnTaRQUq6UNRqQDWBwRkdbGk4mY8O0xZN0uRhsPW/wxqwc6eTlIHYsaiJmJHPOHt8GnY9tDYSLHjgspeGzVUaTeGe2cyFixOCIiaDQC/9t+Ca//eh4laoEhQW7Y/FwoPOw507kxeDS4GdY/EwJHKwXO38jGiGWHceFGttSxiCTD4ojIyBWp1Hhx41l8/c9VAMCL/Ztj2ROdYKlg/yJj0sXHEb8/3wMBLtZIySnE2JVHse9SqtSxiCTB4ojIiGUXlGDy6hP4MyIJpnIZloxrj5cebgG5nP2LjJFXE0tseb47ejV3QkGJGs/+GI5Np65JHYuo0bE4IjJSydkFeGzlURy7mgVrpSnWTO2CUR2bSR2LJGZrbobVU7rg0U7NoNYIvPbLOSw/EAOOF0zGhMURkRGKScvD6K+OIDo1Fy42Smyc3g29mjtLHYt0hJmJHJ+MbYcZffwBAIt3RWPBnxd5qT8ZDRZHREbmwo1sjFt1FMnZhfB3tsKW57ujjYed1LFIx8hkMrw+qCXeGdYaALD2SDxe2HAGJWqNxMmIGh6LIyIjEp5wE098cwyZt4sR1NQOm5/rjmYOllLHIh32VE9ffPlER5iZyLDtXDJmrAtHYQnHQiLDxuKIyEgcjsnAxO+OI7dQhS4+DtpLt4lq8kh7D3wzqTOUpnLsvZSGZ344xcEiyaCxOCIyAvsupWLq2pPIL1ajV3MnfP9UV9iam0kdi/RIn0AXrJnSBZYKE/x7JQNT1pxAXpFK6lhEDYLFEZGB23sxFc+tC0exSoOwNq74dnJnjmFE96V7gBN+eKorbJSmOB6XhYnfHUd2QYnUsYjqHYsjIgO271IqZqwPR4laYGg7dywf3wlKUxOpY5Ee6+zjiPXPhMDOwgxnEm9h8uoTyC1kgUSGhcURkYE6EJWGGetOlxZGQe74YlwHmJrwI08Prl0ze/z8TDfYW5rh7LVbmLLmJG6ziY0MCP+lJDJAB6PTMP3HcBSrNRjc1g2fP87CiOpXaw9brJsWAltzU4Qn3LzTp40FEhkG/mtJZGAOx2Tg2TuF0aA2bncuw+ZHnepf26Z2+HFaCGyUpjgRl4VnfjjFy/zJIPBfTCIDcjrxJp754RSKVRoMbO2KpeNZGFHDau9pj7VPdYWVwgSHYzJLz1iqOFAk6Tf+q0lkIC4l52DK6hPay/VZGFFjCfZ2wJqpXWFhZoK/L6fjpU1noeZUI6TH+C8nkQGIz7iNid+dQE6hCp287LFqYjCvSqNG1dXXEasmBsPMRIa/ziXj7a0XOFkt6S0WR0R6Ljm7ABO+PY6MvCK0dLPBmildOY4RSeKhFs5YMq4DZDLgp+OJ+HT3ZakjEd0XFkdEeiw7vwSTvjuBG7cK4NPEEj9OC4GdJUe+JukMa+eBD0a2BQAsOxCDb/+9KnEiorpjcUSkp4pUajz74ylcScuDq60S654OgbONUupYRJgQ4o1XwwIBAB/8dQlbTl+XOBFR3bA4ItJDGo3AK5vP4XhcFqyVplg7tSuaOVhKHYtI6/k+/pjW0xcA8Pqv53AkJkPiRES1x+KISA99tDMKf0YkwVQuw6qJwWjlbit1JKIKZDIZ3hzSCkPbuaNELTD9x3BEp+RKHYuoVlgcEemZtYfjsOqf0n4cH49phx4BThInIqqaXC7Dp2Pbo6uPI3KLVJiy5gRSsguljkVUIxZHRHpk54UULNh2EQDwalggRndqJnEiouqZm5ng60nB8HO2QnJ2IaauPYk8zsNGOo7FEZGeOJ14Ey9uOAMhgPEhXni+j7/UkYhqxd5Sge+ndoWTtQKXknPw/PrTUKk5ijbpLhZHRHog6VYBnv0hHEUqDfq1dMF7j7SBTCaTOhZRrXk6WmL1lC6wMDPBP5fT8cFfl6SORHRPLI6IdFx+sQrP/HBKO8jj0ic6wpTTgpAeatfMHkvGtQcArD0Sj59PJEqciKhq/BeWSIeVXrIfgcikHDSxUuDbyZ1hpeTo16S/BrV1x5yHWwAA3v79Ao5dzZQ4EVFlLI6IdNiX+69g+/kUmJnIsHJiMMcyIoMwq18Ahrf3gEojMGNdOK5l5UsdiagCFkdEOuqvc8n4fO8VAMDCkUHo4uMocSKi+iGTyfDxo+0Q1NQON/NLMO37k8gtLJE6FpEWiyMiHXThRjbmbD4LAJjW0xePdfGUNhBRPbNQmOCbSZ3hYqPE5dQ8vLTxLNQaIXUsIgAsjoh0TkZeEZ754RQKSzTo3cIZ8wa3lDoSUYNwszPH15M6Q2Eqx95Lafh0d7TUkYgAsDgi0ikqtQazfzqD5OxC+Dlb4UtemUYGroOnPRaPaQcA+OpgLHZHpkiciIjFEZFO+WT3ZRy9mgkrhQm+nhgMOwszqSMRNbgRHZriqR6lk9TO2RSBuIzbEiciY8fiiEhH7LyQgpV/xwIAPh7THgEuNhInImo884a0RBcfB+QWqfDcj+HIL+YUIyQdFkdEOuBqeh5e2RwBoLQD9tB27hInImpcZiZyLB/fCU7WSkSn5uKNLechBDtokzQMpjiKj4/HtGnT4OvrCwsLC/j7+2P+/PkoLi6usN65c+fQq1cvmJubw9PTEx9//LFEiYlK5Rer8Ny6cOQVqdDVxxFz2QGbjJSLrTmWj+8IE7kMv59Nwo/HEqSOREbKYIqjqKgoaDQarFq1CpGRkViyZAlWrlyJN954Q7tOTk4OBg4cCG9vb4SHh2Px4sV499138fXXX0uYnIyZEAJzfz2Py6l5cLZRYtn4jjBjB2wyYiF+TbRXaL6/7SLCE25KnIiMkUwY8HnLxYsXY8WKFbh69SoAYMWKFXjzzTeRkpIChUIBAJg7dy5+//13REVF1WqbOTk5sLOzQ3Z2NmxtbRssOxmHtYfj8O6fF2Eql+HnZ7txoEcilP5omPXTGfx1Phmutkr89UIvOFkrpY5Feq4u398G/RM1Ozsbjo7/fdkcPXoUDz30kLYwAoCwsDBER0fj5s2qf50UFRUhJyenwo2oPpy/no2F20tnJp83pBULI6I7ZDIZPhrTDgEu1kjNKcLLmyKg4QCR1IgMtjiKiYnB0qVLMX36dO2ylJQUuLq6Vliv7H5KStVjayxatAh2dnbam6cnRyqmB5dbWIJZP59GiVogrI0rnurhI3UkIp1irTTFVxM6wdxMjn8up+Obf69KHYmMiM4XR3PnzoVMJqv2dneT2I0bNzBo0CCMHTsWzzzzzAO9/rx585Cdna29Xbt27YG2RySEwFu/X0BCZj6a2lvg40fbQyaTSR2LSOe0cLXB/OFtAACLd0XjdCL7H1HjMJU6QE3mzJmDKVOmVLuOn5+f9v+TkpLQt29fdO/evVJHazc3N6SmplZYVnbfzc2tym0rlUoolWzrpvqzOfw6tp5Ngolchi+f6AA7Sw70SHQvj3fxxKGYDPx1Lhkv/HwGf73Qi4OjUoPT+eLI2dkZzs7OtVr3xo0b6Nu3L4KDg7FmzRrI5RVPjIWGhuLNN99ESUkJzMxKP1x79uxBYGAgHBwc6j070d1i0nIxf2skAODlh1sg2Jv9jIiqI5PJsGh0EM5dv4VrWQWYt+Uclo/vxLOt1KB0vlmttm7cuIE+ffrAy8sLn3zyCdLT05GSklKhL9H48eOhUCgwbdo0REZGYuPGjfjiiy/w8ssvS5icjEVhiRqzfjqDghI1egY4YUZvf6kjEekFW3MzLH2iE0zlMmw/n4KfTiRKHYkMnM6fOaqtPXv2ICYmBjExMWjWrFmFx8pGK7Czs8Pu3bsxc+ZMBAcHw8nJCe+88w6effZZKSKTkXl/20VEpeTCyVqBz8a1h1zOX75EtdXB0x6vD2qJhdsv4b0/LyLY2wEt3TicCjUMgx7nqCFwnCO6HzsvJOO5dacBAD881RUPtahdUzER/UejEXjq+5M4GJ2OABdrbJvdE+ZmJlLHIj3BcY6IdEhaTiHmbTkPAJje24+FEdF9kstl+HRsezjbKBGTlocPd9Ru8F6iumJxRNSAhBB49ZdzuJlfgjYetpjzcKDUkYj0WhNrJRaPaQcAWHskHv9cTpc4ERkiFkdEDWjdsQT8fTkdClM5Ph/XAQpTfuSIHlSfQBdMCvUGALyyOQI3bxfX8AyiuuG/1EQNJDY9Tzs9yNxBLdHc1UbiRESGY97gVvBztkJabhHe+v0C2H2W6hOLI6IGUKLW4KWNZ1FYokHPACdM6e4jdSQig2KhMMHn4zrAVC7DX+eT8duZG1JHIgPC4oioASzddwXnrmfDzsIMn4zlZftEDaFdM3u82L85AGD+1khcv5kvcSIyFCyOiOpZeMJNLDsQAwD4YGRbuNmZS5yIyHDN6OOPjl72yC1SYc6mCKg1bF6jB8fiiKge5Rer8PKms9AIYGQHDwxv7yF1JCKDZmoix5LHOsBSYYLjcVn47tBVqSORAWBxRFSPPt4ZjYTMfLjbmWPBiLZSxyEyCj5OVnh7WGsAwCe7LyMmLU/iRKTvWBwR1ZPjVzOx9kg8AODDR9tx5nCiRvR4F0/0au6EYpUGr/3C5jV6MCyOiOpBQbEar/16DgAwrrMnenMUbKJGJZPJ8OGj7WCtNMXpxFtYczhO6kikx1gcEdWDT3b/15z25rBWUschMkpN7S3w5tDSz9/iXdGIy7gtcSLSVyyOiB7QqfgsrL7zK/V/o4Nga87mNCKpPN7FEz0DnFCk0uDVzWxeo/vD4ojoARSWqPHqL+cgBDAmuBn6BrpIHYnIqJU2rwXBSmGCUwk38f2dfoBEdcHiiOgBfLq79NS9q60Sbw9tLXUcIgLQzMES84aUNq99vCsK8WxeozpicUR0n8ITsvDtodLmtEWjg2BnyeY0Il0xvqsXuvs3QWGJBq/9cg4aNq9RHbA4IroPRSo1Xv/1PIQARndqin4tXaWORETlyOUyfPRoO1gqTHAiPgvrjydIHYn0CIsjovuw8uBVxKTlwclagXeGsTmNSBd5OlritbBAAKUDtKbmFEqciPQFiyOiOopNz8PyO3OnvTO8DewtFRInIqJ7mRjqg/aepXOvvftHpNRxSE+wOCKqA41GYN6W8yhWa9An0BnD27lLHYmIqmEil+HD0UEwlcuw40IKdkemSB2J9ACLI6I62Bx+DSfismBhZoL3R7SFTCaTOhIR1aCVuy2eecgPAPDO1kjkFpZInIh0HYsjolpKzy3C/7ZHAQDmDGwBT0dLiRMRUW292L85vJtYIiWnEJ/uvix1HNJxLI6Iaun9bReRXVCCtk1tMaW7j9RxiKgOzM1MsHBkEADg+6PxOJN4U+JEpMtYHBHVwsHoNPwRkQS5DFg0qh1MTfjRIdI3PZs7YXTHphACmLflPErUGqkjkY7iv/BENcgvVuGt3y8AAJ7q4YugZnYSJyKi+/Xm0FZwsDRDVEouvvn3qtRxSEexOCKqwZf7YnD9ZgGa2lvgpYdbSB2HiB5AE2sl3roz1c+X+67gWla+xIlIF7E4IqpGTFouvr3z63LBI21gpTSVOBERPajRnZqim58jCks0eG/bRanjkA5icUR0D0IIvLM1EiqNwIBWLhjQmlOEEBkCmUyG90e0halchj0XU7E/KlXqSKRjWBwR3cOf55JxJDYTSlM55g9vI3UcIqpHzV1tMK2nLwBg/h+RKCxRS5yIdAmLI6Iq5BWp8MGd0+0z+wZwTCMiA/RC/+ZwszXHtawCrDgYK3Uc0iEsjoiq8Pmey0jLLYJ3E0s8e2dkXSIyLFZKU7x9Z+LoFX/HIiHztsSJSFewOCK6S3RKLtYciQdQ2gnb3MxE2kBE1GCGBLmhZ4ATilUavPtHJIQQUkciHcDiiKgcIQTe3noBao1AWBtX9Al0kToSETUgmUyGBSPawMxEhgPR6dhzkZ2zicURUQW/nbmBE3FZMDeT4x12wiYyCv7O1nimV2nz+YI/L6KgmJ2zjR2LI6I7cgtLtBPLzu7XHE3tLSRORESNZVa/ADS1t8CNWwX46mCM1HFIYiyOiO5Ytj8GGXlF8HWywtO9fKWOQ0SNyFJhireHtQIArPrnKkfONnIsjogAxGXcxurDcQCAt4e1gtKUnbCJjE1YGzd092+CYpUGi3ZckjoOSYjFERGAhX9dRIlaoHcLZ/RlJ2wioySTyfDO8NaQy4Dt51NwNDZT6kgkERZHZPT+vpyOvZfSYCqX4e1hrSCTyaSOREQSaelmiwkh3gCABX9GQq3hpf3GiMURGbUStQbv3xkJe1KoDwJcbCRORERSe/nhFrCzMENUSi42nEyUOg5JgMURGbX1xxIQk5YHRysFXuzfXOo4RKQDHKwUeGlA6b8Hn+6+jOyCEokTUWNjcURGK+t2MT7bcxnAnV+KlmYSJyIiXTGhmzcCXKyRdbsYX+67InUcamQsjshoLdlzGTmFKrR0s8ETXb2kjkNEOsTMRK6dd+37I/GIScuTOBE1JhZHZJSiUnKw/ngCAOCd4a1hImcnbCKqqHcLZwxo5QKVRuCDvy5KHYcaEYsjMjpCCHyw7RI0Ahjc1g3d/Z2kjkREOurNoa1hZiLDweh0HIhOkzoONRIWR2R0Dl5Ox6GYDChM5Jg3uJXUcYhIh/k6WWFKdx8AwKLtl6BSa6QNRI2CxREZFZVag0XbS0e+ndzdG15NLCVORES6blbf5rCzMMPl1Dz8En5d6jjUCFgckVH5Jfw6Lqfmwc7CDLP68tJ9IqqZnaUZZvcLAAB8tucybhepJE5EDY3FERmN20UqfHrn0v0X+jfnpftEVGsTQ73h5WiJtNwifPPvVanjUANjcURG45t/ryI9twhejpaY2M1b6jhEpEeUpiZ4fVBLAMCqv68iLadQ4kTUkFgckVFIyynEqr9Lf+29PqglFKZ86xNR3QwJckNHL3sUlKi1A8iSYeI3BBmFz/ZcRkGJGh297DEkyE3qOESkh2QyGd4aWnqF66ZT1xCdkitxImooLI7I4EWn5GLTqWsAgLeGtoJMxgEfiej+BHs7YnBbN2gEsGjHJanjUANhcUQGb9GO0gEfhwS5IdjbUeo4RKTnXh/UEqby0oEh/72SLnUcagAsjsigHY7JwMHodJiZyPBaWEup4xCRAfBxssLE0NKLOv63PQoajZA4EdU3FkdksIQQ+GhnFABgQog3fJysJE5ERIbihX7NYaM0xaXkHPx5LknqOFTPDLI4KioqQocOHSCTyXD27NkKj507dw69evWCubk5PD098fHHH0sTkhrczgspOHc9G1YKE8y6M4AbEVF9cLBSYHpvPwDAp7svo1jFaUUMiUEWR6+99ho8PDwqLc/JycHAgQPh7e2N8PBwLF68GO+++y6+/vprCVJSQ1KpNVi8OxoA8HQvPzhZKyVORESGZmoPXzhZK5GYlY+Ndy76IMNgcMXRjh07sHv3bnzyySeVHlu/fj2Ki4uxevVqtGnTBo8//jheeOEFfPbZZxIkpYb0S/h1XE2/DUcrBZ7u5St1HCIyQFZKU7zQv/Ss9Jf7riC/mNOKGAqDKo5SU1PxzDPP4Mcff4SlZeUJRY8ePYqHHnoICoVCuywsLAzR0dG4efNmY0alBlRYosbne68AAGb2DYCNOacJIaKG8XgXL3g6WiA9twhrDsdLHYfqicEUR0IITJkyBc899xw6d+5c5TopKSlwdXWtsKzsfkpKSpXPKSoqQk5OToUb6bYfjsYjJacQTe0tMCHES+o4RGTAFKZyzHk4EACw8u9Y3MovljgR1QedL47mzp0LmUxW7S0qKgpLly5Fbm4u5s2bV6+vv2jRItjZ2Wlvnp6e9bp9ql/ZBSVYfiAWAPB/A5rD3MxE4kREZOgeae+Blm42yC1UYcXfsVLHoXqg88XRnDlzcOnSpWpvfn5+2L9/P44ePQqlUglTU1MEBJS2A3fu3BmTJ08GALi5uSE1NbXC9svuu7lVPaXEvHnzkJ2drb1du8ZOd7rsm3+uIrugBM1drDG6UzOp4xCREZDLZXhtUOnZo7WH45GcXSBxInpQplIHqImzszOcnZ1rXO/LL7/EBx98oL2flJSEsLAwbNy4ESEhIQCA0NBQvPnmmygpKYGZWWk/lD179iAwMBAODg5VblepVEKp5JVO+iAtpxDfHYoDALwSFggTOacJIaLG0TfQBV18HHAy/ia+3HcFi0a3kzoSPQCdP3NUW15eXmjbtq321qJFCwCAv78/mjUrPYMwfvx4KBQKTJs2DZGRkdi4cSO++OILvPzyy1JGp3qydH8MCkrU6OBpj4GtXWt+AhFRPZHJZHhtUOko/JtOXUdsep7EiehBGExxVBt2dnbYvXs34uLiEBwcjDlz5uCdd97Bs88+K3U0ekDXsvLx84lEAKXzHnFyWSJqbF18HNG/pQvUGoEley5LHYcegM43q90vHx8fCFF5vpt27drh33//lSARNaQv912BSiPQM8AJof5NpI5DREZqzsBA7ItKw7ZzyZjVLwct3WyljkT3wajOHJFhisu4jS1nbgAAXh7YQuI0RGTMWnvYYkhQ6QU+PHukv1gckd77Yu9lqDUCfQOd0cmr6o71RESN5f8GtIBMBuyKTMWFG9lSx6H7wOKI9NqV1FxsjSidEfvlOwOxERFJqYWrDR5pXzq/52c8e6SXWByRXvt87xUIAQxs7YqgZnZSxyEiAgC82L855DJgf1QaTidyeip9w+KI9NbFpBz8dT4ZAPDSw+xrRES6w8/5v4Fo2fdI/7A4Ir21ZG/pPzhD27mjlTuvCCEi3fJi/+Ywlcvw75UMnIjLkjoO1QGLI9JL567fwp6LqZDLgJcGNJc6DhFRJZ6OlhjbuXQ+zk93R1c5vAzpJhZHpJfKOjmO6NAUAS42EqchIqra7H4BUJjIcTwuC0diM6WOQ7XE4oj0TnjCTRyMToeJXIYX+/OsERHpLg97CzzRlWeP9A2LI9I7n9/pa/Rop6bwcbKSOA0RUfVm9g2A0lSO04m38M+VDKnjUC2wOCK9cibxJv69kgETuQyz+/GsERHpPhdbczzZzRtA6VRHPHuk+1gckV5Zuj8GADC6Y1N4OlpKnIaIqHamP+QHhakc4Qk3cZR9j3QeiyPSG+evZ2N/VBrkstLT1ERE+sLF1hzju3oBAD7fd0XiNFQTFkekN77cX/oPyogO7GtERPpnem8/KEzkOBGXhWNXefZIl7E4Ir1wMSkHey6mQsazRkSkp9ztLPBYl9JRs7/k2SOdxuKI9MKyA6X/kAwNckeAi7XEaYiI7s+MPgEwM5HhSGwmTsZz1GxdxeKIdN7l1FzsuJACALxCjYj0WlN7C4wJ5tkjXcfiiHTesv0xEAIY3NYNgW4cDZuI9NvzfQK0c66dTrwpdRyqAosj0mmx6XnYdi4JADCrH/saEZH+83S0xOhOTQEAS3n2SCexOCKdtvxADDQCGNDKFW087KSOQ0RUL2b2DYCJXIYD0ek4d/2W1HHoLiyOSGclZN7G1rOlZ41e6M+zRkRkOLybWGFEBw8AwJf7YiROQ3djcUQ666sDsVBrBPoEOqNdM3up4xAR1auZfQMgkwF7L6UiOiVX6jhUTq2Lo6SkpIbMQVTBtax8/Hr6OgBeoUZEhsnf2RpD2roDAFYc5NkjXVLr4qhNmzb46aefGjILkdY3/16FSiPQM8AJwd4OUschImoQM/r4AwD+iEhCYma+xGmoTK2Lo4ULF2L69OkYO3YssrI4cBU1nPTcImw8eQ0AR8MmIsPWtqkdHmrhDI0AVv0TK3UcuqPWxdHzzz+Pc+fOITMzE61bt8aff/7ZkLnIiK09EocilQYdPO3Rzc9R6jhERA3q+TtnjzaHX0dabqHEaQgATOuysq+vL/bv349ly5Zh9OjRaNWqFUxNK27i9OnT9RqQjEtuYQl+OJoAoPR0s0wmkzgREVHDCvF1RLC3A8ITbuK7Q3GYN7iV1JGMXp2KIwBISEjAli1b4ODggBEjRlQqjogexPrjicgtVCHAxRoPt3KVOg4RUYOTyWR4vo8/pn1/CuuOJuD53gGwszSTOpZRq1Nl880332DOnDkYMGAAIiMj4ezs3FC5yAgVlqjx3aE4AMBzvf0hl/OsEREZh34tXdDSzQZRKbn44Wg8ZvfnVbpSqnWfo0GDBuH111/HsmXLsGXLFhZGVO9+PX0d6blF8LAz1w6ORkRkDGQymfbKtTVH4lFQrJY4kXGrdXGkVqtx7tw5TJo0qSHzkJFSqTVY9fdVAMAzD/nBzITjkxKRcRka5A4vR0tk3S7GhpOJUscxarX+BtqzZw+aNWvWkFnIiO24kILErHw4WJphXBdPqeMQETU6UxM5pvf2AwB8/c9VFKs0EicyXvx5TpITQuCrg6Xje0zt4QtLBTv5E5FxerRTMzjbKJGcXYjfz96QOo7RYnFEkvv7cjouJefAUmGCSaHeUschIpKMuZkJnu7pCwBY+Xfp/JLU+FgckeTKzhqN7+oFe0uFxGmIiKQ1oZs3bM1NcTX9NnZHpkgdxyixOCJJhSdk4URcFsxMZHi6l5/UcYiIJGetNMWU7j4ASs8eCcGzR42NxRFJasXB0ivURndsBjc7c4nTEBHphkndfaA0lSPiejZOxHE+08bG4ogkcyU1F3svpUImA57tzbNGRERlnKyVeDS49Arxb/69KnEa48PiiCRT9oEPa+0Gf2dridMQEemWaT19IZMBey+lISYtT+o4RoXFEUkiLbcQv59JAlA66CMREVXk72yNAXfmmPzuEM8eNSYWRySJH44koFitQScvewR7O0gdh4hIJ02/8+Px19M3kJ5bJHEa48HiiBpdfrEK644nAACe5VkjIqJ7CvZ2QEcvexSrNPjhaLzUcYwGiyNqdL+GX8et/BJ4N7HEw63dpI5DRKSzZDIZnr0zzMmPxxKQX6ySOJFxYHFEjUqtEfj2UByA0s6GJnKZxImIiHTbwDZu8G5iiVv5Jfgl/LrUcYwCiyNqVHsupiIhMx92FmYYE8yJjImIamIil2mnFPn23zhOKdIIWBxRoyq7fH9iN29OMEtEVEtjgj3hYGmGxKx87OKUIg2OxRE1mvCEmwhPuAmFiRyTunOCWSKi2rJQmGBit9J/N1f9c5VTijQwFkfUaL69c9ZoZEcPuNhwqhAiorqYGOoDhakcEddu4VTCTanjGDQWR9QoEjJva08Fc4JZIqK6c7ZR4tFOpX01V/3NQSEbEosjahSrD8VBI4A+gc5o4WojdRwiIr30dK/Sjtl7L6VySpEGxOKIGtyt/GJsOlV6+ekzPGtERHTfyk8psvZInMRpDBeLI2pw648noqBEjdbutuju30TqOEREem3ancv6fw2/gVv5xRKnMUwsjqhBFas0WHskHgDwzEO+kMk46CMR0YPo5ueIVu62KChRY8PJa1LHMUgsjqhB/XU+Cem5RXC1VWJokIfUcYiI9J5MJsPUHj4AgB+OxEOl1kgbyACxOKIGI4TAmsPxAEoHfVSY8u1GRFQfHmnvgSZWCiRlF2JXZKrUcQwOv62owZxOvIlz17OhMJXjia5eUschIjIY5mYmmHBnUMjVh9kxu74ZXHH0119/ISQkBBYWFnBwcMDIkSMrPJ6YmIihQ4fC0tISLi4uePXVV6FScZbjhrD6zlmjkR080MRaKW0YIiID82Q3L5iZyBCecBMR125JHcegGFRx9Ouvv2LixImYOnUqIiIicPjwYYwfP177uFqtxtChQ1FcXIwjR47g+++/x9q1a/HOO+9ImNowJd0qwM4LpYM+Tu3hK3EaIiLD42JjjuHtSvtyruHZo3olEwYyQYtKpYKPjw8WLFiAadOmVbnOjh07MGzYMCQlJcHVtXSciJUrV+L1119Heno6FApFja+Tk5MDOzs7ZGdnw9bWtl73wZB8tDMKKw7GopufIzY8Gyp1HCIig3T+ejaGLzsEU7kMh+f2g6stp2a6l7p8fxvMmaPTp0/jxo0bkMvl6NixI9zd3TF48GBcuHBBu87Ro0cRFBSkLYwAICwsDDk5OYiMjJQitkEqKFbj5xOJAHjWiIioIQU1s0NXH0eoNALrjiVIHcdgGExxdPVq6Twz7777Lt566y1s27YNDg4O6NOnD7KysgAAKSkpFQojANr7KSkpVW63qKgIOTk5FW5Uvd/P3sCt/BJ4OlpoR3IlIqKGUXZZ//rjiSgsUUsbxkDofHE0d+5cyGSyam9RUVHQaErHeXjzzTfx6KOPIjg4GGvWrIFMJsPmzZvv+/UXLVoEOzs77c3T07O+ds0glV6+X9r2PTnUByZyDvpIRNSQHm7tiqb2Fsi6XYytZ29IHccg6HxxNGfOHFy6dKnam5+fH9zd3QEArVu31j5XqVTCz88PiYmlTTxubm5ITa04HkTZfTc3typff968ecjOztberl3jaKTVORyTicupebBUmGBsZxaSREQNzdREjindfQAAqw/Fw0C6EkvKVOoANXF2doazs3ON6wUHB0OpVCI6Oho9e/YEAJSUlCA+Ph7e3qVjQYSGhmLhwoVIS0uDi4sLAGDPnj2wtbWtUFSVp1QqoVTyMvTaKjtrNCa4GewszCROQ0RkHB7r4okley8jOjUXR2Mz0T3ASepIek3nzxzVlq2tLZ577jnMnz8fu3fvRnR0NGbMmAEAGDt2LABg4MCBaN26NSZOnIiIiAjs2rULb731FmbOnMkCqB7EZ9zG/ug0AMDkO79iiIio4dlZmGFMcDMAHBSyPuj8maO6WLx4MUxNTTFx4kQUFBQgJCQE+/fvh4ODAwDAxMQE27Ztw4wZMxAaGgorKytMnjwZ7733nsTJDcPaI/EQAugT6Ax/Z2up4xARGZUp3X3ww9EE7ItKQ3zGbfg4WUkdSW8ZzDhHjYXjHFUtt7AEoYv2I69Ihe+f6oreLWpuCiUiovo1Zc0JHIxOx9M9ffHWsKq7ixgroxzniKS1+dR15BWp4O9shYeas62biEgKk0N9AACbTl1DQTEv679fLI7ogWk0Aj8cjQcATOnhC5mMl+8TEUmhdwtneDlaIqdQxcv6HwCLI3pg/8ZkID4zHzZKU4zu2FTqOERERksul2Fit9IrtL8/msDL+u8TiyN6YD/eOWv0aHAzWCkNqo8/EZHeGdu5GczN5LiUnIPwhJtSx9FLLI7ogVzLyse+qNLL9yeGekuchoiI7C0VGNG+9Cz+90c539r9YHFED+SnE4kQAugZ4MTL94mIdETZj9Ud55ORllMocRr9w+KI7lthiRobT5ZOp/JkN541IiLSFW2b2iHY2wEqjcDPJzjtVV2xOKL7tv18MrJuF8PDzhwDWrlIHYeIiMqZdOfs0frjCShRayROo19YHNF9++FOW/b4EC+YmvCtRESkSwa3dYeTtRJpuUXYHZla8xNIi99odF/OX8/G2Wu3YGYiw7guXlLHISKiuyhM5Rjf1RMA8P2dq4qpdlgc0X0pG/RxSJA7nG04aS8RkS4aH+INE7kMJ+KyEJWSI3UcvcHiiOrsVn4x/ohIAvBfmzYREekeNztzhLVxBfBfVwiqGYsjqrPNp66jSKVBa3dbdPJykDoOERFVY9Kd+dZ+O30D2QUl0obREyyOqE40GoF1x0t/fUwK9eY8akREOi7E1xEtXK1RUKLGr+HXpY6jF1gcUZ38fSUdCZn5sDU3xYgOnEeNiEjXyWQy7dmjH48lQKPhfGs1YXFEdfLjnTbrsZ09YaEwkTgNERHVxqiOTWGtNEVcxm0cvZopdRydx+KIau1aVj4ORJfOo8YRsYmI9IeV0hSjOpae7f/peKLEaXQfiyOqtXXHEyAE0Ku5E3ydrKSOQ0REdTA+pHRMul2RKUjL5Xxr1WFxRLVSrNLgl1OlHfkm8qwREZHeaeVui05e9lBpBDafYsfs6rA4olrZFZmCzNvFcLM1R7+WnEeNiEgfjQ8p/XH784lEqNkx+55YHFGtlLVRP9bFk/OoERHpqWHt3GFrborrNwvwz5V0qePoLH7LUY2upufh6NVMyGXA4108pY5DRET3ydzMBGOCS/8dX3+MHbPvhcUR1ejnE6UfoL6BLvCwt5A4DRERPYjxIaXF0f6oVCRnF0icRjexOKJqFZao8cudEVWf6OolcRoiInpQAS42CPF1hEYAG05ckzqOTmJxRNXaFZmCm/klcLczR59AZ6njEBFRPSi7rH/jyWtQqTUSp9E9LI6oWuvvdMQex47YREQGY1BbNzhaKZCSU4j9UWlSx9E5/Laje4pJy8WJuCzIZaXFERERGQalqQnGdm4G4L8fwfQfFkd0Tz8dL22L7tfSFe527IhNRGRInuhS2rT2z5V0XMvKlziNbmFxRFUqLFHj19OlHbEnhLAjNhGRofFxskKv5k4Q4r+rkqkUiyOq0vbzycguKEFTews81IIdsYmIDFHZj99Np66hWMWO2WVYHFGVykbEfryLJ0zkMonTEBFRQ+jfyhXONkpk5BVjz8VUqePoDBZHVMnl1FycSrgJE7kMj7EjNhGRwTIzkWtnPlh/PEHiNLqDxRFVUnbWaEArF7jamkuchoiIGtK4Lp6QyYAjsZlIzGTHbIDFEd2loPi/jthlszcTEZHhauZgiZ4BTgBK+x4RiyO6y1/nk5FbqIKnowV63fmwEBGRYXv8zmX9m8M5YjbA4ojusulk6a+GcZ09IWdHbCIiozCgtQscrRRIzSnC35fTpY4jORZHpBWbnocT8aUjYo8JZkdsIiJjoTQ1weiOTQEAG06yaY3FEWmVtTX3CXSBmx07YhMRGZOyaaL2R6UhLadQ4jTSYnFEAIAStQa/ht8AwHnUiIiMUXNXGwR7O0CtEfjlzoU5xorFEQEo/aWQkVcEJ2sl+rV0kToOERFJoOzH8caT1yCEkDiNdFgcEYD/OmI/GtwUZiZ8WxARGaOhQe6wVpoiITMfx65mSR1HMvwWJKRkF+JAdBoA4LHObFIjIjJWVkpTDG/vAQDYeNJ4J6NlcUT49fR1aATQ1ccR/s7WUschIiIJlU0nsv1CCrLzSyROIw0WR0ZOoxHYeKdJjfOoERFRu2Z2aOlmg2KVBr+fvSF1HEmwODJyx+IykZiVD2ulKYYEuUkdh4iIJCaTybRnj34+kWiUHbNZHBm5so7Yj3TwgKXCVOI0RESkC0Z2bAqFqRxRKbk4fyNb6jiNjsWREcvOL8H2CykASqcLISIiAgB7SwUGty1tTTDGEbNZHBmxrRE3UKzSoKWbDdo1s5M6DhER6ZCyMY/+OJuE/GKVxGkaF4sjI7bhxJ1JZrt4QibjJLNERPSfbr5N4N3EEnlFKmw7lyx1nEbF4shIXbiRjYvJOVCYyjHqzmSDREREZeRymXbsu19OGdd0IiyOjNSGO4N7hbVxg72lQuI0RESki0Z3agq5DDgRn4X4jNtSx2k0LI6MUGGJGlvPJgH4b7AvIiKiu7nbWaBnc2cApQMGGwsWR0ZoV2QKcgtVaOZggVC/JlLHISIiHTY2uBkA4Nfw61BrjGPMIxZHRuiX8NLq/9FOzSCXsyM2ERHd28OtXWFrboqk7EIcjc2UOk6jYHFkZJJuFeBQTAaA0uKIiIioOuZmJnikQ+lktJvDjWPMIxZHRua3MzcgBBDi6wivJpZSxyEiIj0wNri0f+rOCynIKTT8yWhZHBkRIYS2SW1MMM8aERFR7bRrZofmLtYoUmmwLcLwxzwyqOLo8uXLGDFiBJycnGBra4uePXviwIEDFdZJTEzE0KFDYWlpCRcXF7z66qtQqYxj5M/TiTcRl3EblgoTDAlylzoOERHpCZlMhrGdS39UG0PTmkEVR8OGDYNKpcL+/fsRHh6O9u3bY9iwYUhJKZ0/TK1WY+jQoSguLsaRI0fw/fffY+3atXjnnXckTt44ys4aDQlyh5WSk8wSEVHtjezYFCZyGc4k3kJMWp7UcRqUwRRHGRkZuHLlCubOnYt27dqhefPm+PDDD5Gfn48LFy4AAHbv3o2LFy9i3bp16NChAwYPHoz3338fy5cvR3FxscR70LAKitXaU6FsUiMiorpysTFHnxalYx6V/dg2VAZTHDVp0gSBgYH44YcfcPv2bahUKqxatQouLi4IDg4GABw9ehRBQUFwdXXVPi8sLAw5OTmIjIyscrtFRUXIycmpcNNHuy+mILdIBU9HC3T1cZQ6DhER6aGyprUtp69DpdZInKbhGExxJJPJsHfvXpw5cwY2NjYwNzfHZ599hp07d8LBwQEAkJKSUqEwAqC9X9b0drdFixbBzs5Oe/P01M8RpTm2ERERPah+LV3hYGmGtNwi/HtnWBhDpPPF0dy5cyGTyaq9RUVFQQiBmTNnwsXFBf/++y9OnDiBkSNHYvjw4UhOvv+e9fPmzUN2drb2du2a/nVE49hGRERUHxSmcozoUDpZuSFPRqvzvXLnzJmDKVOmVLuOn58f9u/fj23btuHmzZuwtbUFAHz11VfYs2cPvv/+e8ydOxdubm44ceJEheempqYCANzc3KrctlKphFKpfPAdkdCW09chBNDNzxGejhzbiIiI7t/Yzs2w9kg89lxMxa38YoOcvFzniyNnZ2c4OzvXuF5+fj4AQC6veDJMLpdDoyltFw0NDcXChQuRlpYGFxcXAMCePXtga2uL1q1b13Ny3VBxbCP9bBIkIiLd0cbDDq3cbXEpOQd/RCRhUqiP1JHqnc43q9VWaGgoHBwcMHnyZERERODy5ct49dVXERcXh6FDhwIABg4ciNatW2PixImIiIjArl278NZbb2HmzJl6f3boXsITbiI+Mx+WChMMblv12TEiIqK6KJuMdrOBNq0ZTHHk5OSEnTt3Ii8vD/369UPnzp1x6NAhbN26Fe3btwcAmJiYYNu2bTAxMUFoaCiefPJJTJo0Ce+9957E6RsOxzYiIqL6NrJjU5iZyHD+RjaiUvTzKu7qGNS3ZefOnbFr165q1/H29sb27dsbKZG0CorV2HaOYxsREVH9crRSoF9LF+yKTMWW0zfwxhBbqSPVK4M5c0SV7YpMQV6RCl6OlhzbiIiI6tXoO1c/bz17A2qNkDhN/WJxZMA4thERETWUvoEusLc0Q2pOEY7EGtaYRyyODFRydgEO33mzju7UVOI0RERkaBSmcgxv5wEA2HL6hsRp6heLIwO19WwShAC6+nBsIyIiahij7vz43nkhBbeLVBKnqT8sjgyQEAK/3aniR/GsERERNZCOnvbwdbJCQYkaOy9UPQ2XPmJxZIAuJucgOjUXClM5hgS5Sx2HiIgMlEwmw6iOpT/CfztjOE1rLI4MUNlZowGtXGBnYSZxGiIiMmRlxdHh2AykZBdKnKZ+sDgyMCq1BlsjkgAAozpybCMiImpYnneGixEC+P2sYZw9YnFkYA7HZiI9twgOlmbo3aLmOemIiIgeVFn/1tKJzvV/zCMWRwbmt9OlYxsNb+8BhSkPLxERNbwhQe5QmMpxOTUPkUn6P50Ivz0NyO0iFXZFpgL4rw2YiIioodlZmOHhVq4ADKNjNosjA7LzQgoKStTwdbJCB097qeMQEZERKRtweOvZJKjUGonTPBgWRwakrFof2aEpZDJOF0JERI3noRbOaGKlQEZeEf6N0e/pRFgcGYiU7ELtdCFsUiMiosZmZiLH8Pal04n8pufTibA4MhBbz96AEEBnbwd4NeF0IURE1PjKmtZ2RaYgt7BE4jT3j8WRgShrUuN0IUREJJWgpnYIcLFGkUqDHXo8nQiLIwNwMSkHUSm5UJjIMSzIQ+o4RERkpMpPJ7LlztAy+ojFkQH47UzpG7BfSxfYWXK6ECIiks6ojk0hkwHHrmbhxq0CqePcFxZHek6tEdh69s50IWxSIyIiiXnYWyDE1xEA8Oed6az0DYsjPXc4JgNpuUWwtzRD30AXqeMQERFhRIf/xjzSRyyO9NzvdzpiD2vnzulCiIhIJwxp6w4zExkuJefgcmqu1HHqjN+meqygWI1dkaVXA4zswCY1IiLSDXaWZuhzpzXjdz2cToTFkR7bF5WK28VqNHOwQLC3g9RxiIiItEaWa1oTQkicpm5YHOmxsrbcR9p7cLoQIiLSKf1bucBaaYobtwoQnnBT6jh1wuJIT2Xnl+BgdBqA/zq+ERER6QpzMxOEtXEDoH8ds1kc6akdF5JRohZo6WaDQDcbqeMQERFVMqJD6cDEf51PRolaI3Ga2mNxpKe0TWodOCI2ERHppu7+TeBkrUDW7WIcupIhdZxaY3Gkh1KyC3EsLhMAMLwdiyMiItJNpiZyDLvzPfX7Wf25ao3FkR7adi4JQgCdvR3g6WgpdRwiIqJ7Kmta2x2ZivxilcRpaofFkR4qa1IbwSY1IiLScR087eHdxBIFJWrsuZgqdZxaYXGkZ2LT83D+RjZM5DIMCXKXOg4REVG1ZDIZRrQv/TGvL1etsTjSM3/ceWP1au6EJtZKidMQERHV7JE7Q878czkdWbeLJU5TMxZHekQIgT8i2KRGRET6JcDFGm2b2kKlEfjrfLLUcWrE4kiPnL+RjbiM2zA3k+Ph1m5SxyEiIqo17XQiejDXGosjPVLWVvtwazdYK00lTkNERFR7w9p5QCYDTiXcxLWsfKnjVIvFkZ5QawT+LGtSa88mNSIi0i9uduYI9WsCANouIrqKxZGeOH41E2m5RbCzMMNDLZyljkNERFRnZf1lt+r4gJAsjvREWZPakCB3KEx52IiISP8MausOhYkcl1PzEJ2SK3Wce+K3rB4oUqmx/UJp735epUZERPqqtPXDCUDpbA+6isWRHjgYnY7cQhXcbM3R1cdR6jhERET3bfidfrPbziVDCCFxmqqxONIDZR2xh7d3h1wukzgNERHR/RvQyhXmZnLEZdxGZFKO1HGqxOJIx+UXq7DvUhoAaGc2JiIi0ldWSlP0b+kK4L8f/7qGxZGO23cpDQUlang5WqJdMzup4xARET2wYe1K5wbV1aY1Fkc6rqzD2rB27pDJ2KRGRET6r29LF1gpTHDjVgFOJ96SOk4lLI50WG5hCQ5EpwNgkxoRERkOczMTDGxTOg2WLjatsTjSYXsupqJYpYG/sxVaudtIHYeIiKjeDG9f2rT21/lkqDW61bTG4kiHbTtXOrZR6Xw0bFIjIiLD0TPAGXYWZkjPLcLxuEyp41TA4khH3covxr9XSpvUyqprIiIiQ6EwlWPQnaa1spMBuoLFkY7aFZmCErVASzcbBLiwSY2IiAxP2YCQO84no0StkTjNf1gc6aiyKrrsjUNERGRouvk5wslagZv5JTgckyF1HC0WRzooI68IR2JL21/LxoIgIiIyNKYmcgwJKv2e+zNCd5rWWBzpoB0XUqDWCAQ1tYN3Eyup4xARETWYsqFqdkemoEilljhNKRZHOmhbubnUiIiIDFlnbwe42Zojt0iFv++M7Sc1Fkc6JjWnECfiswAAQznwIxERGTi5XKbtQvKnjly1xuJIx/x1LhlCAJ287NHU3kLqOERERA2u7OKjvRdTkV+skjgNiyOdUzaXGq9SIyIiY9GumR28HC1RUKLGvktpUsfRn+Jo4cKF6N69OywtLWFvb1/lOomJiRg6dCgsLS3h4uKCV199FSpVxQr04MGD6NSpE5RKJQICArB27dqGD19L12/m43TiLchk0PbeJyIiMnQy2X9Na2UnCaSkN8VRcXExxo4dixkzZlT5uFqtxtChQ1FcXIwjR47g+++/x9q1a/HOO+9o14mLi8PQoUPRt29fnD17Fv/3f/+Hp59+Grt27Wqs3ajWX3faWrv6OMLV1lziNERERI2n7Kq1A9HpyCuStmlNb4qjBQsW4KWXXkJQUFCVj+/evRsXL17EunXr0KFDBwwePBjvv/8+li9fjuLiYgDAypUr4evri08//RStWrXCrFmzMGbMGCxZsqQxd+WetHOpsUmNiIiMTCt3G/g5WaFYpcG+S6mSZtGb4qgmR48eRVBQEFxdXbXLwsLCkJOTg8jISO06AwYMqPC8sLAwHD169J7bLSoqQk5OToVbQ4jPuI3zN7JhIpdhcFu3BnkNIiIiXSWTyTBU27Qm7VVrBlMcpaSkVCiMAGjvp6SkVLtOTk4OCgoKqtzuokWLYGdnp715eno2QHogMSsfzjZKdPdvAidrZYO8BhERkS4rK47yi1XQaIRkOSQtjubOnQuZTFbtLSoqSsqImDdvHrKzs7W3a9euNcjrPNTCGcfm9cdnj3VokO0TERHpukBXG5x4oz/WP90NcrlMshymkr0ygDlz5mDKlCnVruPn51erbbm5ueHEiRMVlqWmpmofK/tv2bLy69ja2sLCouoxhZRKJZTKxjmTYyKXwdmGZ42IiMg4yWQyuOjABUmSFkfOzs5wdnaul22FhoZi4cKFSEtLg4uLCwBgz549sLW1RevWrbXrbN++vcLz9uzZg9DQ0HrJQERERPpPb/ocJSYm4uzZs0hMTIRarcbZs2dx9uxZ5OXlAQAGDhyI1q1bY+LEiYiIiMCuXbvw1ltvYebMmdozP8899xyuXr2K1157DVFRUfjqq6+wadMmvPTSS1LuGhEREekQmRBCuh5PdTBlyhR8//33lZYfOHAAffr0AQAkJCRgxowZOHjwIKysrDB58mR8+OGHMDX97wTZwYMH8dJLL+HixYto1qwZ3n777Rqb9srLycmBnZ0dsrOzYWtr+6C7RURERI2gLt/felMc6QoWR0RERPqnLt/fetOsRkRERNQYWBwRERERlcPiiIiIiKgcFkdERERE5bA4IiIiIiqHxRERERFROSyOiIiIiMphcURERERUDosjIiIionIknXhWH5UNKJ6TkyNxEiIiIqqtsu/t2kwMwuKojnJzcwEAnp6eEichIiKiusrNzYWdnV2163ButTrSaDRISkqCjY0NZDJZvW47JycHnp6euHbtmkHO22bo+wcY/j5y//Sfoe8j90//NdQ+CiGQm5sLDw8PyOXV9yrimaM6ksvlaNasWYO+hq2trcG+6QHD3z/A8PeR+6f/DH0fuX/6ryH2saYzRmXYIZuIiIioHBZHREREROWwONIhSqUS8+fPh1KplDpKgzD0/QMMfx+5f/rP0PeR+6f/dGEf2SGbiIiIqByeOSIiIiIqh8URERERUTksjoiIiIjKYXFEREREVA6Lo0a0cOFCdO/eHZaWlrC3t69yncTERAwdOhSWlpZwcXHBq6++CpVKVe12s7KyMGHCBNja2sLe3h7Tpk1DXl5eA+xB3Rw8eBAymazK28mTJ+/5vD59+lRa/7nnnmvE5LXn4+NTKeuHH35Y7XMKCwsxc+ZMNGnSBNbW1nj00UeRmpraSInrJj4+HtOmTYOvry8sLCzg7++P+fPno7i4uNrn6fIxXL58OXx8fGBubo6QkBCcOHGi2vU3b96Mli1bwtzcHEFBQdi+fXsjJa27RYsWoUuXLrCxsYGLiwtGjhyJ6Ojoap+zdu3aSsfK3Ny8kRLXzbvvvlspa8uWLat9jj4dP6Dqf1NkMhlmzpxZ5fq6fvz++ecfDB8+HB4eHpDJZPj9998rPC6EwDvvvAN3d3dYWFhgwIABuHLlSo3brevnuK5YHDWi4uJijB07FjNmzKjycbVajaFDh6K4uBhHjhzB999/j7Vr1+Kdd96pdrsTJkxAZGQk9uzZg23btuGff/7Bs88+2xC7UCfdu3dHcnJyhdvTTz8NX19fdO7cudrnPvPMMxWe9/HHHzdS6rp77733KmSdPXt2teu/9NJL+PPPP7F582b8/fffSEpKwujRoxspbd1ERUVBo9Fg1apViIyMxJIlS7By5Uq88cYbNT5XF4/hxo0b8fLLL2P+/Pk4ffo02rdvj7CwMKSlpVW5/pEjR/DEE09g2rRpOHPmDEaOHImRI0fiwoULjZy8dv7++2/MnDkTx44dw549e1BSUoKBAwfi9u3b1T7P1ta2wrFKSEhopMR116ZNmwpZDx06dM919e34AcDJkycr7N+ePXsAAGPHjr3nc3T5+N2+fRvt27fH8uXLq3z8448/xpdffomVK1fi+PHjsLKyQlhYGAoLC++5zbp+ju+LoEa3Zs0aYWdnV2n59u3bhVwuFykpKdplK1asELa2tqKoqKjKbV28eFEAECdPntQu27Fjh5DJZOLGjRv1nv1BFBcXC2dnZ/Hee+9Vu17v3r3Fiy++2DihHpC3t7dYsmRJrde/deuWMDMzE5s3b9Yuu3TpkgAgjh492gAJ69/HH38sfH19q11HV49h165dxcyZM7X31Wq18PDwEIsWLapy/ccee0wMHTq0wrKQkBAxffr0Bs1ZX9LS0gQA8ffff99znXv9e6SL5s+fL9q3b1/r9fX9+AkhxIsvvij8/f2FRqOp8nF9On4AxG+//aa9r9FohJubm1i8eLF22a1bt4RSqRQ///zzPbdT18/x/eCZIx1y9OhRBAUFwdXVVbssLCwMOTk5iIyMvOdz7O3tK5yJGTBgAORyOY4fP97gmevijz/+QGZmJqZOnVrjuuvXr4eTkxPatm2LefPmIT8/vxES3p8PP/wQTZo0QceOHbF48eJqm0HDw8NRUlKCAQMGaJe1bNkSXl5eOHr0aGPEfWDZ2dlwdHSscT1dO4bFxcUIDw+v8LeXy+UYMGDAPf/2R48erbA+UPqZ1KdjBaDG45WXlwdvb294enpixIgR9/z3RhdcuXIFHh4e8PPzw4QJE5CYmHjPdfX9+BUXF2PdunV46qmnqp3oXJ+OX3lxcXFISUmpcIzs7OwQEhJyz2N0P5/j+8GJZ3VISkpKhcIIgPZ+SkrKPZ/j4uJSYZmpqSkcHR3v+RypfPfddwgLC6tx4t7x48fD29sbHh4eOHfuHF5//XVER0djy5YtjZS09l544QV06tQJjo6OOHLkCObNm4fk5GR89tlnVa6fkpIChUJRqc+Zq6urzh2vqsTExGDp0qX45JNPql1PF49hRkYG1Gp1lZ+xqKioKp9zr8+kPhwrjUaD//u//0OPHj3Qtm3be64XGBiI1atXo127dsjOzsYnn3yC7t27IzIyssEn2a6rkJAQrF27FoGBgUhOTsaCBQvQq1cvXLhwATY2NpXW1+fjBwC///47bt26hSlTptxzHX06fncrOw51OUb38zm+HyyOHtDcuXPx0UcfVbvOpUuXauw0qE/uZ5+vX7+OXbt2YdOmTTVuv3x/qaCgILi7u6N///6IjY2Fv7///Qevpbrs38svv6xd1q5dOygUCkyfPh2LFi3S6eH97+cY3rhxA4MGDcLYsWPxzDPPVPtcqY8hATNnzsSFCxeq7ZMDAKGhoQgNDdXe7969O1q1aoVVq1bh/fffb+iYdTJ48GDt/7dr1w4hISHw9vbGpk2bMG3aNAmTNYzvvvsOgwcPhoeHxz3X0afjp09YHD2gOXPmVFvVA4Cfn1+ttuXm5lapx33ZVUxubm73fM7dndBUKhWysrLu+ZwHdT/7vGbNGjRp0gSPPPJInV8vJCQEQOlZi8b4Yn2QYxoSEgKVSoX4+HgEBgZWetzNzQ3FxcW4detWhbNHqampDXa8qlLXfUxKSkLfvn3RvXt3fP3113V+vcY+hlVxcnKCiYlJpSsDq/vbu7m51Wl9XTFr1iztxRl1PXtgZmaGjh07IiYmpoHS1R97e3u0aNHinln19fgBQEJCAvbu3Vvns636dPzKjkNqairc3d21y1NTU9GhQ4cqn3M/n+P7Um+9l6jWauqQnZqaql22atUqYWtrKwoLC6vcVlmH7FOnTmmX7dq1S6c6ZGs0GuHr6yvmzJlzX88/dOiQACAiIiLqOVn9W7dunZDL5SIrK6vKx8s6ZP/yyy/aZVFRUTrdIfv69euiefPm4vHHHxcqleq+tqErx7Br165i1qxZ2vtqtVo0bdq02g7Zw4YNq7AsNDRUZzv0ajQaMXPmTOHh4SEuX758X9tQqVQiMDBQvPTSS/Wcrv7l5uYKBwcH8cUXX1T5uL4dv/Lmz58v3NzcRElJSZ2ep8vHD/fokP3JJ59ol2VnZ9eqQ3ZdPsf3lbXetkQ1SkhIEGfOnBELFiwQ1tbW4syZM+LMmTMiNzdXCFH6pm7btq0YOHCgOHv2rNi5c6dwdnYW8+bN027j+PHjIjAwUFy/fl27bNCgQaJjx47i+PHj4tChQ6J58+biiSeeaPT9u5e9e/cKAOLSpUuVHrt+/boIDAwUx48fF0IIERMTI9577z1x6tQpERcXJ7Zu3Sr8/PzEQw891Nixa3TkyBGxZMkScfbsWREbGyvWrVsnnJ2dxaRJk7Tr3L1/Qgjx3HPPCS8vL7F//35x6tQpERoaKkJDQ6XYhRpdv35dBAQEiP79+4vr16+L5ORk7a38OvpyDDds2CCUSqVYu3atuHjxonj22WeFvb299grRiRMnirlz52rXP3z4sDA1NRWffPKJuHTpkpg/f74wMzMT58+fl2oXqjVjxgxhZ2cnDh48WOFY5efna9e5ex8XLFggdu3aJWJjY0V4eLh4/PHHhbm5uYiMjJRiF6o1Z84ccfDgQREXFycOHz4sBgwYIJycnERaWpoQQv+PXxm1Wi28vLzE66+/XukxfTt+ubm52u86AOKzzz4TZ86cEQkJCUIIIT788ENhb28vtm7dKs6dOydGjBghfH19RUFBgXYb/fr1E0uXLtXer+lzXB9YHDWiyZMnCwCVbgcOHNCuEx8fLwYPHiwsLCyEk5OTmDNnToVfDgcOHBAARFxcnHZZZmameOKJJ4S1tbWwtbUVU6dO1RZcuuCJJ54Q3bt3r/KxuLi4Cn+DxMRE8dBDDwlHR0ehVCpFQECAePXVV0V2dnYjJq6d8PBwERISIuzs7IS5ublo1aqV+N///lfhLN/d+yeEEAUFBeL5558XDg4OwtLSUowaNapCsaFL1qxZU+V7tvxJZ307hkuXLhVeXl5CoVCIrl27imPHjmkf6927t5g8eXKF9Tdt2iRatGghFAqFaNOmjfjrr78aOXHt3etYrVmzRrvO3fv4f//3f9q/h6urqxgyZIg4ffp044evhXHjxgl3d3ehUChE06ZNxbhx40RMTIz2cX0/fmV27dolAIjo6OhKj+nb8Sv7zrr7VrYPGo1GvP3228LV1VUolUrRv3//Svvt7e0t5s+fX2FZdZ/j+iATQoj6a6QjIiIi0m8c54iIiIioHBZHREREROWwOCIiIiIqh8URERERUTksjoiIiIjKYXFEREREVA6LIyIiIqJyWBwRERERlcPiiIiMmlqtRvfu3TF69OgKy7Ozs+Hp6Yk333xTomREJBWOkE1ERu/y5cvo0KEDvvnmG0yYMAEAMGnSJERERODkyZNQKBQSJySixsTiiIgIwJdffol3330XkZGROHHiBMaOHYuTJ0+iffv2UkcjokbG4oiICIAQAv369YOJiQnOnz+P2bNn46233pI6FhFJgMUREdEdUVFRaNWqFYKCgnD69GmYmppKHYmIJMAO2UREd6xevRqWlpaIi4vD9evXpY5DRBLhmSMiIgBHjhxB7969sXv3bnzwwQcAgL1790Imk0mcjIgaG88cEZHRy8/Px5QpUzBjxgz07dsX3333HU6cOIGVK1dKHY2IJMAzR0Rk9F588UVs374dERERsLS0BACsWrUKr7zyCs6fPw8fHx9pAxJRo2JxRERG7e+//0b//v1x8OBB9OzZs8JjYWFhUKlUbF4jMjIsjoiIiIjKYZ8jIiIionJYHBERERGVw+KIiIiIqBwWR0RERETlsDgiIiIiKofFEREREVE5LI6IiIiIymFxRERERFQOiyMiIiKiclgcEREREZXD4oiIiIioHBZHREREROX8P9v33YNToDyrAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'agent': array([ 3., -8.]), 'target': array([  2., -19.])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# from gym.envs.classic_control import rendering\n",
    "import math\n",
    "\n",
    "def visualize_learning_realtime(agent, env):\n",
    "    plt.ion()  # Turn on interactive mode\n",
    "    fig, ax = plt.subplots()\n",
    "\n",
    "    x_vals = np.linspace(-10, 10, 400)\n",
    "    y_vals = [2*math.pow(x, 3) - 3*math.pow(x, 2) - 12 * x + 1 for x in x_vals]\n",
    "    target_x = 0\n",
    "\n",
    "    agent_x = env._agent_location[0]\n",
    "\n",
    "    line, = ax.plot(x_vals, y_vals, label=\"Curve: -x^2\")\n",
    "    target_circle = plt.Circle((target_x, 0), 0.1, color='red')\n",
    "    agent_circle = plt.Circle((agent_x, -agent_x ** 2), 0.1, color='blue')\n",
    "\n",
    "    ax.add_patch(target_circle)\n",
    "    ax.add_patch(agent_circle)\n",
    "    ax.set_xlabel('X')\n",
    "    ax.set_ylabel('Y')\n",
    "    ax.set_title('Agent Learning Curve Navigation')\n",
    "    ax.legend()\n",
    "\n",
    "    plt.draw()\n",
    "\n",
    "    for _ in range(200):\n",
    "        action = agent.forward(env.observation_space.sample())  # Replace with your agent's action selection\n",
    "        observation, reward, done, _ = env.step(action)\n",
    "\n",
    "        agent_x = observation[0]\n",
    "\n",
    "        agent_circle.center = (agent_x, -agent_x ** 2)\n",
    "        plt.pause(0.01)\n",
    "        plt.draw()\n",
    "\n",
    "        if done:\n",
    "            env.reset()\n",
    "\n",
    "    plt.ioff()\n",
    "    plt.show()\n",
    "\n",
    "visualize_learning_realtime(dqn, env)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "_pYzLBjxUVO-"
   },
   "source": [
    "## Save and load"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "skBuM0XmUV7r"
   },
   "outputs": [],
   "source": [
    "dqn.save_weights('dqn_weights.h5f', overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "IJXeBx9MUYWe"
   },
   "outputs": [],
   "source": [
    "# env = gym.make('CartPole-v0')\n",
    "actions = env.action_space.n\n",
    "states = env.observation_space.shape[0]\n",
    "model = build_model(states, actions)\n",
    "dqn = build_agent(model, actions)\n",
    "dqn.compile(Adam(lr=1e-3), metrics=['mae'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MAjbEHmtUZpj"
   },
   "outputs": [],
   "source": [
    "dqn.load_weights('dqn_weights.h5f')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "K0V5ixvjUa6D"
   },
   "outputs": [],
   "source": [
    "_ = dqn.test(env, nb_episodes=5, visualize=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "LcgVH-ToUdsq"
   },
   "source": [
    "## Parameters"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "lhRzB4a1UheW"
   },
   "source": [
    "* ParallelGCThreads: int\n",
    "* MaxGCPauseMillis: int\n",
    "* GCTimeRatio: int\n",
    "* MaxHeapSize: int\n",
    "* InitialHeapSize: int\n",
    "* YoungGenerationSizeIncrement: int\n",
    "* TenuredGenerationSizeIncrement: int\n",
    "* AdaptiveSizeDecrementScaleFactor: int\n",
    "* ParallelGCBufferWastePct: int\n",
    "* ParallelOldDeadWoodLimiterMean: int\n",
    "* ParallelOldDeadWoodLimiterStdDev: int\n",
    "* PreTouchParallelChunkSize: int\n",
    "\n",
    "* UseGCOverheadLimit: bool\n",
    "* ParallelRefProcBalancingEnabled: bool\n",
    "* ParallelRefProcEnabled: bool\n",
    "* AllowParallelDefineClass: bool\n",
    "* CMSParallelInitialMarkEnabled: bool\n",
    "* CMSParallelRemarkEnabled: bool\n",
    "* CMSParallelSurvivorRemarkEnabled: bool\n",
    "* GCParallelVerificationEnabled: bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Z-Tuatz1Uf7h"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [
    "LcgVH-ToUdsq"
   ],
   "gpuType": "T4",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}