From 98aa1bb21edca431f3bab4ac23a7f029c86fe4f0 Mon Sep 17 00:00:00 2001 From: bruzat Date: Thu, 17 Dec 2020 17:56:36 +0100 Subject: [PATCH 1/5] Add progress bar from tqdm --- TODO.md | 3 +++ blobrl/trainer.py | 14 ++++++++++---- requirements.txt | 3 ++- setup.py | 1 + 4 files changed, 16 insertions(+), 5 deletions(-) diff --git a/TODO.md b/TODO.md index d09beda..d6eb9b3 100644 --- a/TODO.md +++ b/TODO.md @@ -14,6 +14,7 @@ - [x] List Environments for start project - [x] Add gpu option - [x] Render on notebook/collab +- [ ] Add progress bar for training # Agents list @@ -85,6 +86,8 @@ - [ ] Add temporal difference option in all memories - [x] Add Discount reward in experience replay +- [ ] Add average reward + # Environments list - [x] Gym CartPole diff --git a/blobrl/trainer.py b/blobrl/trainer.py index b1caff0..f984d15 100644 --- a/blobrl/trainer.py +++ b/blobrl/trainer.py @@ -4,6 +4,7 @@ import gym import matplotlib.pyplot as plt +from tqdm.auto import tqdm from IPython import display from blobrl import Logger, Record @@ -101,17 +102,22 @@ def evaluate(self, logger=None, render=True): if logger: logger.evaluate() - def train(self, max_episode=1000, nb_evaluation=4, render=True): + def train(self, max_episode=1000, nb_evaluation=4, render=True, progress_bar=True): """ + Star train on *max_episode* episode. - :param nb_evaluation: - :param max_episode: + :param max_episode: maximum episode to train agent + :type max_episode: int + :param nb_evaluation: number of time where we test agent without training + :type nb_evaluation: int :param render: if show env render :type render: bool + :param progress_bar: show or not progress bar of training + :type progress_bar: bool """ self.environment.reset() - for i_episode in range(1, max_episode + 1): + for i_episode in tqdm(range(1, max_episode + 1), disable=not progress_bar): self.do_episode(logger=self.logger, render=render) if nb_evaluation > 0: if nb_evaluation <= 1: diff --git a/requirements.txt b/requirements.txt index 02c57fb..de8e33f 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,4 +2,5 @@ numpy torch torchvision gym -tensorboard \ No newline at end of file +tensorboard +tqdm \ No newline at end of file diff --git a/setup.py b/setup.py index 3f8593c..6a313c1 100644 --- a/setup.py +++ b/setup.py @@ -11,6 +11,7 @@ 'torchvision', 'gym', 'tensorboard', + 'tqdm' ] INSTALL_REQUIRES_NOTBOOK = [ From d2aad70c37fdb4815efe2f7bfc53f85142744881 Mon Sep 17 00:00:00 2001 From: bruzat Date: Tue, 29 Dec 2020 20:27:09 +0100 Subject: [PATCH 2/5] fix depreciationWarning --- blobrl/memories/experience_replay.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/blobrl/memories/experience_replay.py b/blobrl/memories/experience_replay.py index a5632d4..b4eaae4 100644 --- a/blobrl/memories/experience_replay.py +++ b/blobrl/memories/experience_replay.py @@ -58,7 +58,7 @@ def sample(self, batch_size, device): """ idxs = np.random.randint(len(self.buffer), size=batch_size) - batch = np.array([self.get_sample(idx) for idx in idxs]) + batch = np.array([self.get_sample(idx) for idx in idxs], dtype=object) return [torch.Tensor(list(V)).to(device=device) for V in batch.T] From 31714dc903d998730c720c30cb63c6755a856fa5 Mon Sep 17 00:00:00 2001 From: bruzat Date: Tue, 29 Dec 2020 20:44:54 +0100 Subject: [PATCH 3/5] Increase to 0.1.2 --- TODO.md | 2 +- setup.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/TODO.md b/TODO.md index d6eb9b3..4aa7b5f 100644 --- a/TODO.md +++ b/TODO.md @@ -14,7 +14,7 @@ - [x] List Environments for start project - [x] Add gpu option - [x] Render on notebook/collab -- [ ] Add progress bar for training +- [x] Add progress bar for training # Agents list diff --git a/setup.py b/setup.py index 6a313c1..1b400c6 100644 --- a/setup.py +++ b/setup.py @@ -31,7 +31,7 @@ setuptools.setup( author="french ai team", name='blobrl', - version='0.1.1', + version='0.1.2', license="Apache-2.0", description='Reinforcement learning with pytorch ', long_description=README, From 686128d028e67cf330145816f69a4e584a4db1d5 Mon Sep 17 00:00:00 2001 From: bruzat Date: Fri, 8 Jan 2021 11:01:02 +0100 Subject: [PATCH 4/5] Change parameter for AdaptativeEpsilonGreedy --- .../explorations/adaptative_epsilon_greedy.py | 20 ++++++------------- .../test_adaptative_epsilon_greedy.py | 8 ++++---- 2 files changed, 10 insertions(+), 18 deletions(-) diff --git a/blobrl/explorations/adaptative_epsilon_greedy.py b/blobrl/explorations/adaptative_epsilon_greedy.py index 1c9454c..b085ea7 100644 --- a/blobrl/explorations/adaptative_epsilon_greedy.py +++ b/blobrl/explorations/adaptative_epsilon_greedy.py @@ -3,23 +3,20 @@ class AdaptativeEpsilonGreedy(EpsilonGreedy): - def __init__(self, epsilon_max, epsilon_min, step_max, step_min=0): + def __init__(self, epsilon_max, epsilon_min, gamma=0.9999): """ Create AdaptativeEpsilonGreedy :param epsilon_max: value for start exploration :type epsilon_min: float [0.0,1.0], epsilon_max>epsilon_min :param epsilon_min: min value exploration :type epsilon_min: float [0.0,1.0], epsilon_min Date: Tue, 12 Jan 2021 16:28:23 +0100 Subject: [PATCH 5/5] Add parameters linear_dim for simple_network --- blobrl/networks/simple_network.py | 9 +- examples/example_jupyter.ipynb | 652 --------------------------- examples/example_train_jupyter.ipynb | 335 +++++++------- 3 files changed, 177 insertions(+), 819 deletions(-) delete mode 100644 examples/example_jupyter.ipynb diff --git a/blobrl/networks/simple_network.py b/blobrl/networks/simple_network.py index f6155de..424832c 100644 --- a/blobrl/networks/simple_network.py +++ b/blobrl/networks/simple_network.py @@ -6,7 +6,7 @@ class SimpleNetwork(BaseNetwork): - def __init__(self, observation_space, action_space): + def __init__(self, observation_space, action_space, linear_dim=64): """ :param observation_space: @@ -15,12 +15,13 @@ def __init__(self, observation_space, action_space): super().__init__(observation_space=observation_space, action_space=action_space) self.network = nn.Sequential() - self.network.add_module("NetWorkSimple_Linear_Input", nn.Linear(np.prod(flatdim(self.observation_space)), 64)) + self.network.add_module("NetWorkSimple_Linear_Input", + nn.Linear(np.prod(flatdim(self.observation_space)), linear_dim)) self.network.add_module("NetWorkSimple_LeakyReLU_Input", nn.LeakyReLU()) - self.network.add_module("NetWorkSimple_Linear_1", nn.Linear(64, 64)) + self.network.add_module("NetWorkSimple_Linear_1", nn.Linear(linear_dim, linear_dim)) self.network.add_module("NetWorkSimple_LeakyReLU_1", nn.LeakyReLU()) - self.outputs = get_last_layers(self.action_space, last_dim=64) + self.outputs = get_last_layers(self.action_space, last_dim=linear_dim) def forward(self, observation): """ diff --git a/examples/example_jupyter.ipynb b/examples/example_jupyter.ipynb deleted file mode 100644 index 037b082..0000000 --- a/examples/example_jupyter.ipynb +++ /dev/null @@ -1,652 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "ZTuJfCB_CYzh" - }, - "source": [ - "## OpenAI Gym Available Environment\n", - "\n", - "Gym comes with a diverse suite of environments that range from easy to difficult and involve many different kinds of data. View the [full list of environments](https://gym.openai.com/envs) to get the birds-eye view.\n", - "\n", - "- [Classic control](https://gym.openai.com/envs#classic_control) and [toy text](https://gym.openai.com/envs#toy_text): complete small-scale tasks, mostly from the RL literature. They’re here to get you started.\n", - "\n", - "- [Algorithmic](https://gym.openai.com/envs#algorithmic): perform computations such as adding multi-digit numbers and reversing sequences. One might object that these tasks are easy for a computer. The challenge is to learn these algorithms purely from examples. These tasks have the nice property that it’s easy to vary the difficulty by varying the sequence length.\n", - "\n", - "- [Atari](https://gym.openai.com/envs#atari): play classic Atari games. \n", - "\n", - "- [2D and 3D robots](https://gym.openai.com/envs#mujoco): control a robot in simulation. These tasks use the MuJoCo physics engine, which was designed for fast and accurate robot simulation. \n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Don't forget to set matplotlib to inline" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "NEnwOnr6qHbO" - }, - "source": [ - "# CartPole-v1 exemple" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "Fj9G5c5kqM_y" - }, - "source": [ - "## Initialize environment" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 35 - }, - "colab_type": "code", - "id": "5Q7p1iRwdGpE", - "outputId": "fa6bfbf8-a868-402e-a1d7-344ba712b002" - }, - "outputs": [], - "source": [ - "import gym\n", - "env = gym.make('CartPole-v1')\n", - "_ = env.reset()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "mxUtaISFqQ4Q" - }, - "source": [ - "## Initialize agent" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "srJt2AZPp58A" - }, - "outputs": [], - "source": [ - "from blobrl.agents import AgentRandom\n", - "action_space = env.action_space\n", - "observation_space = env.observation_space\n", - "agent = AgentRandom(observation_space=observation_space, action_space=action_space)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "EX_NctEhqfgu" - }, - "source": [ - "## Train" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "fldGbNR2qlDo" - }, - "source": [ - "Create Trainer" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 54 - }, - "colab_type": "code", - "id": "CY1LF52LqeyH", - "outputId": "96567768-4a32-4e02-8fc8-c3f7e17897ab" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "D:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\site-packages\\blobrl\\trainer.py:28: UserWarning: be sure of agent have good input and output dimension\n", - " warnings.warn(\"be sure of agent have good input and output dimension\")\n" - ] - } - ], - "source": [ - "from blobrl import Trainer\n", - "trainer = Trainer(environment=env, agent=agent, log_dir=\"./logs\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "cGq2ksiRqkRR" - }, - "source": [ - "Start train" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "0BACJeOjqkXO" - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "trainer.train(max_episode=10, nb_evaluation=0, render=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "trainer.train(max_episode=1, nb_evaluation=0, render=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# MountainCar-v0 exemple" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "import gym\n", - "env = gym.make('MountainCar-v0')\n", - "_ = env.reset()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Initialize agent" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "from blobrl.agents import AgentRandom\n", - "action_space = env.action_space\n", - "observation_space = env.observation_space\n", - "agent = AgentRandom(observation_space=observation_space, action_space=action_space)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Train" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create Trainer" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "from blobrl import Trainer\n", - "trainer = Trainer(environment=env, agent=agent, log_dir=\"./logs\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Start train" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "trainer.train(max_episode=1, nb_evaluation=0, render=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Copy-v0 exemple" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "import gym\n", - "env = gym.make('Copy-v0')\n", - "_ = env.reset()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Initialize agent" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "from blobrl.agents import AgentRandom\n", - "action_space = env.action_space\n", - "observation_space = env.observation_space\n", - "agent = AgentRandom(observation_space=observation_space, action_space=action_space)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Train" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create Trainer" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "from blobrl import Trainer\n", - "trainer = Trainer(environment=env, agent=agent, log_dir=\"./logs\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Start train" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total length of input instance: 4, step: 3\n", - "==========================================\n", - "Observation Tape : BCE\u001b[42mB\u001b[0m \n", - "Output Tape : \n", - "Targets : BCEB \n", - "\n", - "Current reward : 0.000\n", - "Cumulative reward : 0.000\n", - "Action : Tuple(move over input: right,\n", - " write to the output tape: False,\n", - " prediction: D)\n", - "Total length of input instance: 4, step: 3\n", - "==========================================\n", - "Observation Tape : BCE\u001b[42mB\u001b[0m \n", - "Output Tape : \n", - "Targets : BCEB \n", - "\n", - "Current reward : 0.000\n", - "Cumulative reward : 0.000\n", - "Action : Tuple(move over input: right,\n", - " write to the output tape: False,\n", - " prediction: D)\n" - ] - } - ], - "source": [ - "trainer.train(max_episode=1, nb_evaluation=0, render=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# FrozenLake-v0 example" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "import gym\n", - "env = gym.make('FrozenLake-v0')\n", - "_ = env.reset()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Initialize agent" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "from blobrl.agents import AgentRandom\n", - "action_space = env.action_space\n", - "observation_space = env.observation_space\n", - "agent = AgentRandom(observation_space=observation_space, action_space=action_space)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Train" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create Trainer" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "D:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\site-packages\\blobrl\\trainer.py:28: UserWarning: be sure of agent have good input and output dimension\n", - " warnings.warn(\"be sure of agent have good input and output dimension\")\n" - ] - } - ], - "source": [ - "from blobrl import Trainer\n", - "trainer = Trainer(environment=env, agent=agent, log_dir=\"./logs\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Start train" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " (Right)\n", - "S\u001b[41mF\u001b[0mFF\n", - "FHFH\n", - "FFFH\n", - "HFFG\n", - " (Right)\n", - "S\u001b[41mF\u001b[0mFF\n", - "FHFH\n", - "FFFH\n", - "HFFG\n" - ] - } - ], - "source": [ - "trainer.train(max_episode=1, nb_evaluation=0, render=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " (Right)\n", - "SFF\u001b[41mF\u001b[0m\n", - "FHFH\n", - "FFFH\n", - "HFFG\n", - " (Right)\n", - "SFF\u001b[41mF\u001b[0m\n", - "FHFH\n", - "FFFH\n", - "HFFG\n" - ] - } - ], - "source": [ - "trainer.train(max_episode=1, nb_evaluation=0, render=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Assault-v0 example" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "import gym\n", - "env = gym.make('Assault-v0')\n", - "_ = env.reset()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Initialize agent" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "from blobrl.agents import AgentRandom\n", - "action_space = env.action_space\n", - "observation_space = env.observation_space\n", - "agent = AgentRandom(observation_space=observation_space, action_space=action_space)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Train" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create Trainer" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "from blobrl import Trainer\n", - "trainer = Trainer(environment=env, agent=agent, log_dir=\"./logs\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Start train" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "trainer.train(max_episode=1, nb_evaluation=0, render=True)" - ] - } - ], - "metadata": { - "colab": { - "collapsed_sections": [], - "name": "Copie de Gym_Envs_1_preamble_evn_list.ipynb", - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "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.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/examples/example_train_jupyter.ipynb b/examples/example_train_jupyter.ipynb index 65b5161..0bc49fb 100644 --- a/examples/example_train_jupyter.ipynb +++ b/examples/example_train_jupyter.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -59,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -78,14 +78,14 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "observation_space= Box(4,) action_space= Discrete(2)\n" + "observation_space= Box(-3.4028234663852886e+38, 3.4028234663852886e+38, (4,), float32) action_space= Discrete(2)\n" ] } ], @@ -105,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 4, "metadata": { "colab": {}, "colab_type": "code", @@ -114,7 +114,9 @@ "outputs": [], "source": [ "from blobrl.agents import DQN\n", - "agent = DQN(observation_space=env.observation_space, action_space=env.action_space)" + "from blobrl.explorations import EpsilonGreedy\n", + "\n", + "agent = DQN(observation_space=env.observation_space, action_space=env.action_space, greedy_exploration=EpsilonGreedy(0.1))" ] }, { @@ -139,7 +141,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -149,7 +151,16 @@ "id": "CY1LF52LqeyH", "outputId": "96567768-4a32-4e02-8fc8-c3f7e17897ab" }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "D:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\site-packages\\blobrl\\trainer.py:29: UserWarning: be sure of your agent need to have good input and output dimension\n", + " warnings.warn(\"be sure of your agent need to have good input and output dimension\")\n" + ] + } + ], "source": [ "from blobrl import Trainer\n", "trainer = Trainer(environment=env, agent=agent, log_dir=\"./logs\")" @@ -167,25 +178,40 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "metadata": { "colab": {}, "colab_type": "code", "id": "0BACJeOjqkXO" }, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "350d1d1695724a95a6974f6d42a2e3e6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/500 [00:00" ] @@ -202,7 +228,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -218,7 +244,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -229,9 +255,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "observation_space= Box(-1.2000000476837158, 0.6000000238418579, (2,), float32) action_space= Discrete(3)\n" + ] + } + ], "source": [ "print(\"observation_space=\",env.observation_space, \"action_space=\",env.action_space)" ] @@ -245,12 +279,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "from blobrl.agents import DQN\n", - "agent = DQN(observation_space=env.observation_space, action_space=env.action_space)" + "from blobrl.memories import ExperienceReplay\n", + "from blobrl.explorations import AdaptativeEpsilonGreedy\n", + "import torch.optim as optim\n", + "\n", + "memory = ExperienceReplay(max_size=50000, gamma=0.99) # gamma is discount reward factor (default is 0)\n", + "greedy_exploration = AdaptativeEpsilonGreedy(epsilon_max=0.8, epsilon_min=0.05, gamma=0.997)\n", + "\n", + "agent = DQN(observation_space=env.observation_space, action_space=env.action_space, memory=memory, gamma=0.85, greedy_exploration=greedy_exploration)\n", + "agent.optimizer = optim.Adam(agent.network.parameters(), lr=0.001)" ] }, { @@ -269,7 +311,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -286,125 +328,59 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0e01d138b5d04125906a230ba83adfb2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "trainer.evaluate()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "env.close()" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Copy-v0 exemple" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import gym\n", - "env = gym.make('Copy-v0')\n", - "_ = env.reset()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(\"observation_space=\",env.observation_space, \"action_space=\",env.action_space)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Initialize agent" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from blobrl.agents import DQN\n", - "agent = DQN(observation_space=env.observation_space, action_space=env.action_space)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Train" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create Trainer" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from blobrl import Trainer\n", - "trainer = Trainer(environment=env, agent=agent, log_dir=\"./logs\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Start train" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "trainer.train(max_episode=200, nb_evaluation=0, render=False)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "trainer.evaluate()\n", - "env.close()" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -414,7 +390,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -425,7 +401,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -449,7 +425,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -473,14 +449,14 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "D:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\site-packages\\blobrl\\trainer.py:28: UserWarning: be sure of your agent need to have good input and output dimension\n", + "D:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\site-packages\\blobrl\\trainer.py:29: UserWarning: be sure of your agent need to have good input and output dimension\n", " warnings.warn(\"be sure of your agent need to have good input and output dimension\")\n" ] } @@ -499,16 +475,31 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d780ac7b1e5049dcb02fbb3a695bc1a8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mgym\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0menv\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mgym\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmake\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Assault-v0'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3\u001b[0m \u001b[0m_\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0menv\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mD:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\site-packages\\gym\\envs\\registration.py\u001b[0m in \u001b[0;36mmake\u001b[1;34m(id, **kwargs)\u001b[0m\n\u001b[0;32m 143\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 144\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mmake\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mid\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 145\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mregistry\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmake\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mid\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 146\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 147\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mspec\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mid\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mD:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\site-packages\\gym\\envs\\registration.py\u001b[0m in \u001b[0;36mmake\u001b[1;34m(self, path, **kwargs)\u001b[0m\n\u001b[0;32m 88\u001b[0m \u001b[0mlogger\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minfo\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Making new env: %s'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpath\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 89\u001b[0m \u001b[0mspec\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mspec\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 90\u001b[1;33m \u001b[0menv\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mspec\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmake\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 91\u001b[0m \u001b[1;31m# We used to have people override _reset/_step rather than\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 92\u001b[0m \u001b[1;31m# reset/step. Set _gym_disable_underscore_compat = True on\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mD:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\site-packages\\gym\\envs\\registration.py\u001b[0m in \u001b[0;36mmake\u001b[1;34m(self, **kwargs)\u001b[0m\n\u001b[0;32m 57\u001b[0m \u001b[0menv\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mentry_point\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0m_kwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 58\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 59\u001b[1;33m \u001b[0mcls\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mload\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mentry_point\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 60\u001b[0m \u001b[0menv\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcls\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0m_kwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 61\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mD:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\site-packages\\gym\\envs\\registration.py\u001b[0m in \u001b[0;36mload\u001b[1;34m(name)\u001b[0m\n\u001b[0;32m 16\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mload\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 17\u001b[0m \u001b[0mmod_name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mattr_name\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\":\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 18\u001b[1;33m \u001b[0mmod\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mimportlib\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimport_module\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmod_name\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 19\u001b[0m \u001b[0mfn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mattr_name\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 20\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mD:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\importlib\\__init__.py\u001b[0m in \u001b[0;36mimport_module\u001b[1;34m(name, package)\u001b[0m\n\u001b[0;32m 125\u001b[0m \u001b[1;32mbreak\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 126\u001b[0m \u001b[0mlevel\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 127\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0m_bootstrap\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_gcd_import\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mlevel\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpackage\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlevel\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 128\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 129\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mD:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\importlib\\_bootstrap.py\u001b[0m in \u001b[0;36m_gcd_import\u001b[1;34m(name, package, level)\u001b[0m\n", + "\u001b[1;32mD:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\importlib\\_bootstrap.py\u001b[0m in \u001b[0;36m_find_and_load\u001b[1;34m(name, import_)\u001b[0m\n", + "\u001b[1;32mD:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\importlib\\_bootstrap.py\u001b[0m in \u001b[0;36m_find_and_load_unlocked\u001b[1;34m(name, import_)\u001b[0m\n", + "\u001b[1;32mD:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\importlib\\_bootstrap.py\u001b[0m in \u001b[0;36m_load_unlocked\u001b[1;34m(spec)\u001b[0m\n", + "\u001b[1;32mD:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\importlib\\_bootstrap_external.py\u001b[0m in \u001b[0;36mexec_module\u001b[1;34m(self, module)\u001b[0m\n", + "\u001b[1;32mD:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\importlib\\_bootstrap.py\u001b[0m in \u001b[0;36m_call_with_frames_removed\u001b[1;34m(f, *args, **kwds)\u001b[0m\n", + "\u001b[1;32mD:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\site-packages\\gym\\envs\\atari\\__init__.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mfrom\u001b[0m \u001b[0mgym\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0menvs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0matari\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0matari_env\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mAtariEnv\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32mD:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\site-packages\\gym\\envs\\atari\\atari_env.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 8\u001b[0m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[1;32mimport\u001b[0m \u001b[0matari_py\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 10\u001b[0m \u001b[1;32mexcept\u001b[0m \u001b[0mImportError\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 11\u001b[0m raise error.DependencyNotInstalled(\n", + "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python38\\site-packages\\atari_py\\__init__.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mfrom\u001b[0m \u001b[1;33m.\u001b[0m\u001b[0male_python_interface\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[1;33m*\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mos\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0m_game_dir\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mabspath\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdirname\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m__file__\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"atari_roms\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python38\\site-packages\\atari_py\\ale_python_interface.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 15\u001b[0m 'ale_interface/libale_c.so'))\n\u001b[0;32m 16\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 17\u001b[1;33m ale_lib = cdll.LoadLibrary(os.path.join(os.path.dirname(__file__),\n\u001b[0m\u001b[0;32m 18\u001b[0m 'ale_interface/ale_c.dll'))\n\u001b[0;32m 19\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mD:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\ctypes\\__init__.py\u001b[0m in \u001b[0;36mLoadLibrary\u001b[1;34m(self, name)\u001b[0m\n\u001b[0;32m 457\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 458\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mLoadLibrary\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 459\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_dlltype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 460\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 461\u001b[0m \u001b[0mcdll\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mLibraryLoader\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mCDLL\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mD:\\Users\\nathan\\Anaconda3\\envs\\RL\\lib\\ctypes\\__init__.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, name, mode, handle, use_errno, use_last_error, winmode)\u001b[0m\n\u001b[0;32m 379\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 380\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mhandle\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 381\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_handle\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_dlopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 382\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 383\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_handle\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mhandle\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mFileNotFoundError\u001b[0m: Could not find module 'C:\\Users\\Nathan\\AppData\\Roaming\\Python\\Python38\\site-packages\\atari_py\\ale_interface\\ale_c.dll' (or one of its dependencies). Try using the full path with constructor syntax." + ] + } + ], "source": [ "import gym\n", "env = gym.make('Assault-v0')\n", @@ -553,17 +573,19 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "observation_space= Box(250, 160, 3) action_space= Discrete(7)\n" - ] - } - ], + "outputs": [], + "source": [ + "trainer.evaluate()\n", + "env.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "print(\"observation_space=\",env.observation_space, \"action_space=\",env.action_space)" ] @@ -577,7 +599,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -601,7 +623,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -618,7 +640,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -627,22 +649,9 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "trainer.evaluate()\n", "env.close()" @@ -677,7 +686,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.8.5" } }, "nbformat": 4,