diff --git a/TODO.md b/TODO.md index db6ad41..d09beda 100644 --- a/TODO.md +++ b/TODO.md @@ -82,7 +82,8 @@ - [ ] Prioritized Experience Replay (Schaul *et al.*, [2015](https://arxiv.org/abs/1511.05952)) - [ ] Hindsight Experience Replay (Andrychowicz *et al.*, [2017](https://arxiv.org/abs/1707.01495)) -- [ ] Add advantage in all memories or create Advantage buffer +- [ ] Add temporal difference option in all memories +- [x] Add Discount reward in experience replay # Environments list diff --git a/blobrl/memories/experience_replay.py b/blobrl/memories/experience_replay.py index 37ff4de..a5632d4 100644 --- a/blobrl/memories/experience_replay.py +++ b/blobrl/memories/experience_replay.py @@ -1,23 +1,29 @@ import numpy as np import torch +from collections import deque from blobrl.memories import MemoryInterface class ExperienceReplay(MemoryInterface): - def __init__(self, max_size=5000): + def __init__(self, max_size=5000, gamma=0.0): """ + Create ExperienceReplay with buffersize equal to max_size - :param max_size: + :param max_size: size max of buffer + :type max_size: int + :param gamma: gamma for discount reward. 0 disable discount reward + :type gamma: float [0,1] """ - self.max_size = max_size - self.buffer = np.empty(shape=(self.max_size, 5), dtype=np.object) - self.index = 0 - self.size = 0 + self.buffer = deque(maxlen=max_size) + if not 0 <= gamma <= 1: + raise ValueError("gamma need to be in range [0,1] not " + str(gamma)) + self.gamma = gamma def append(self, observation, action, reward, next_observation, done): """ + Store one couple of value :param observation: :param action: @@ -25,12 +31,11 @@ def append(self, observation, action, reward, next_observation, done): :param next_observation: :param done: """ - self.buffer[self.index] = np.array([np.array(observation), action, reward, np.array(next_observation), done]) - self.index = (self.index + 1) % self.max_size - self.size = min(self.size + 1, self.max_size) + self.buffer.append([observation, action, reward, next_observation, done]) def extend(self, observations, actions, rewards, next_observations, dones): """ + Store many couple of value :param observations: :param actions: @@ -43,14 +48,36 @@ def extend(self, observations, actions, rewards, next_observations, dones): def sample(self, batch_size, device): """ + returns *batch_size* of samples - :param device: + :param device: torch device to run agent + :type device: torch.device :param batch_size: - :return: + :type batch_size: int + :return: list """ - idxs = np.random.randint(self.size, size=batch_size) + idxs = np.random.randint(len(self.buffer), size=batch_size) - return [torch.Tensor(list(V)).to(device=device) for V in self.buffer[idxs].T] + batch = np.array([self.get_sample(idx) for idx in idxs]) + + return [torch.Tensor(list(V)).to(device=device) for V in batch.T] + + def get_sample(self, idx): + """ + returns sample at idx position. if self.gamma not equal to 0 apply discount reward. + + :param idx: torch device to run agent + :type idx: int + :return: [observation, action, reward, next_observation, done] + """ + sample = self.buffer[idx] + if self.gamma == 0 or sample[4] is True: + return sample + + if idx + 1 < len(self.buffer): + sample[2] = sample[2] + self.gamma * self.get_sample(idx + 1)[2] + + return sample def __str__(self): - return 'ExperienceReplay-' + str(self.max_size) + return 'ExperienceReplay-' + str(self.buffer.maxlen) + '-' + str(self.gamma) diff --git a/blobrl/memories/memory_interface.py b/blobrl/memories/memory_interface.py index 7e36668..5b84192 100644 --- a/blobrl/memories/memory_interface.py +++ b/blobrl/memories/memory_interface.py @@ -6,6 +6,7 @@ class MemoryInterface(metaclass=abc.ABCMeta): @abc.abstractmethod def append(self, observation, action, reward, next_observation, done) -> None: """ + Store one couple of value :param observation: :param action: @@ -18,6 +19,7 @@ def append(self, observation, action, reward, next_observation, done) -> None: @abc.abstractmethod def extend(self, observations, actions, rewards, next_observations, dones) -> None: """ + Store many couple of value :param observations: :param actions: @@ -30,9 +32,13 @@ def extend(self, observations, actions, rewards, next_observations, dones) -> No @abc.abstractmethod def sample(self, batch_size, device): """ + returns *batch_size* sample - :param device: + :param device: torch device to run agent + :type: torch.device :param batch_size: + :type: int + :return: list """ pass diff --git a/examples/example_train_jupyter.ipynb b/examples/example_train_jupyter.ipynb index b460bdf..65b5161 100644 --- a/examples/example_train_jupyter.ipynb +++ b/examples/example_train_jupyter.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -59,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -78,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -105,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "metadata": { "colab": {}, "colab_type": "code", @@ -139,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -149,16 +149,7 @@ "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 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" - ] - } - ], + "outputs": [], "source": [ "from blobrl import Trainer\n", "trainer = Trainer(environment=env, agent=agent, log_dir=\"./logs\")" @@ -176,7 +167,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, "metadata": { "colab": {}, "colab_type": "code", @@ -189,12 +180,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAGCCAYAAADkJxkCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAAM6klEQVR4nO3dW4ycZ2HG8febmfV6ba8dx4HESTkECOEYmqZN6UGtVJSgBgUhqHJRoV6nvYAbkJAAoXDXIC56USH1IFWtqlZVLqBVoWmgVEWQNpRwTCDBuElx3AUf1mxsr3d2Z4YrXIzZHce7+72zz/x+0kr2zmvvI0se/ffbnf2a0WhUAACSdWoPAADYboIHAIgneACAeIIHAIgneACAeIIHAIjXG/O416wDADtFs94DrvAAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAAPEEDwAQT/AAW2q41i/9s4tl0L9QewrARb3aA4CdazQaleXTz13yvuef+3Y59p8PlRt/5R3l8O2/W2kZwKUED/CCnV04UoaD1VJGo/LdT/9J7TkAYwke4AU7+tk/L6vnz9SeAXDFfA8PsC3OLnz3si93AdQieIAX7PAvva00nY0vEC99/4ly7sQz7QwCGEPwAC/Yi173W6XpdmvPALhiggcAiCd4AIB4ggfYNscefagsPfed2jMABA9wdW5794OlNBs/hQz658tosNbSIoD1CR7gqnRndteeAHDFBA8AEE/wANtq0D9fRsNB7RnAlBM8wFXbfc0NY8/8z7/9ZTl/6lgLawDWJ3iAq/a63/tw7QkAV0TwAADxBA8AEE/wANvuxBOfL2sr52rPAKaY4AE2oSkv/c3fH3vq1NOPlkF/uYU9AD+f4AGuWtM05dpb3lx7BsBYggcAiCd4gFY89Y8f82UtoBrBA2xKp7ervP6+B8aeWz13poxGoxYWAVxO8ACb0jRN6e6aqz0DYEOCBwCIJ3iA1gxWzvmyFlCF4AE2r+mUmb0Hxx771t9/yJ3TgSoED7BpM3Pz5ZZ73lt7BsC6BA8AEE/wAADxBA/QqoWvfto3LgOtEzzAlpjZc6Bcf9tdY8/93+P/3MIagEsJHmBL9Gb3lAMvu632DICfS/AAAPEED9C6Jx/6aO0JwJQRPMCW2Xf9K8vLfvsPxp5bWfphC2sA/p/gAbZM0+mW7szu2jMALiN4AIB4ggdo36iUQX+59gpgiggeYEt1erOlO7tnwzOj4Vr55t99sKVFAIIH2GIHXvqGcuMd99aeAXAJwQMAxBM8AEA8wQNUMRqslhNP/kftGcCUEDzAltt3+JYyf9NrNjwzXOuXha8/3NIiYNoJHmDL7Tn0krL3RS+vPQPgIsEDAMQTPEA1q+cWy9HP/UXtGcAUEDxANaPhoPSfP1l7BjAFBA+wLQ7fcW+59lW/WnsGQClF8ADbpNPtlabTrT0DoJQieIDKRqNhGa6t1p4BhBM8wLbpzs6VptPb8Mz5E8+Wo5/7s5YWAdNK8ADb5iW/dl+Zv+nW2jMABA8AkE/wAADxBA9Q3crSybJ07Nu1ZwDBBA+wra679TfKzN5rNjxzYfF4WTz63+0MAqaS4AG21cFX3FFm5vbXngFMOcEDAMQTPABAPMEDTITTRx4rP/jGI7VnAKEED7DtXn3v+8qufddueGa41i+D/nJLi4BpI3iAbdedmS2lNLVnAFNM8AATYzQcltFwUHsGEEjwAK3o7d479szC1z5TTj71xRbWANNG8ACteO07P1i6u+ZqzwCmlOABAOIJHgAgnuABJsrzx58uK0sna88AwggeoDU33H5PKc3GL09f/N6Xy/LpYy0tAqaF4AFac8Ob7i5N42kHaJ9nHgAgnuABAOIJHmDiPPuFvy3nT/5v7RlAEMEDtOq2dz849sza8lIZDlZbWANMC8EDtKo7O/4WEwBbTfAAE2k0HJTRaFR7BhBC8AAT6el/+nhZWfph7RlACMEDtG7XvkO1JwBTRvAArWqaprz+vgdqzwCmjOABAOIJHmBiLR59vAzXvDwd2DzBA7Su6XTKi9/4lrHnjn/5k2WweqGFRUA6wQO0rul0y+Hb76k9A5giggcAiCd4AIB4ggeYaE996o/dVwvYNMEDVNGd3VNe844PjD23snSiFHeYADZJ8ABVNE2n9Hbvqz0DmBKCBwCIJ3iAiTdYveDO6cCmCB6gnqZTervnxx77xt+8r4UxQDLBA1QzO3+ovPKtf1R7BjAFBA8AEE/wADvC6SOP1Z4A7GCCB6hqZs+Bcs3Lf3HsuWf+/a+2fQuQS/AAVc3OHyqHXv3rtWcA4QQPABBP8AAA8QQPsDOMhuU7n3qw9gpghxI8QHX7f+G15aY73zn23IXF4y2sARIJHqC6Tm9X6c7uqT0DCCZ4gE1bWFgovV5vU29/eP/9Yz/OmTNnNv1xfvbtkUceaeFfCKitV3sAkGEwGGzuzw+HV3Su1yllZXVzH+unuSkpTAdXeICJsLK6Vs6vrF78fX84W1YGc5e87Zo9UB564L6KK4GdyhUeYCJ85r+OlJuu21/uf/svl+XB3vLYqbeWpbXrLjnTa/rlls5fV1oI7GSu8AAT5eza/vL44u9cFjullLI22lUePfW2CquAnU7wABPle2ffVE73D6/7+MzM7nLzzXe2uAhIIHiAifHkMyfK0eOnNzyzd+/Bctdd72lpEZBC8AAT40tPfL987cgPas8AAgkeYEeZaS6UW+e/UnsGsMMIHmCi3LzvW+XgzPpXeXqd1XL97mdbXAQkEDzARNnfWyy3H/x8me+duuyxbtMvd177LxVWATudn8MDTJQ//eRj5cbr5subb10tw1G3lFLKuz7yD6W/OihNMyqf6J4tq2tX9lOZAX5C8AAT5UfnVsr7P/Gvpdf97MX3Pb/cv/jrMxU2ATvfhsHjHjPAldjq54rl/tqW/n3jeK6DDE3TrP/YRv/R5+bmPAsAY41Go7KyslJ7xlWZmZkp3W639gxgCywvL69bPBsGTylF8ABjLSwslMOH1//pyJPs4YcfLnfffXftGcDWWDd4vEoLAIgneACAeIIHAIgneACAeIIHAIgneACAeIIHAIgneACAeIIHAIgneACAeIIHAIi34d3SAa5Ur7czn046HZ/3wTRw81AAIIWbhwIA00vwAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxemMeb1pZAQCwjVzhAQDiCR4AIJ7gAQDiCR4AIJ7gAQDiCR4AIN6PAbD2vOY4stcpAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -211,7 +202,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -227,7 +218,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -238,17 +229,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "observation_space= Box(2,) action_space= Discrete(3)\n" - ] - } - ], + "outputs": [], "source": [ "print(\"observation_space=\",env.observation_space, \"action_space=\",env.action_space)" ] @@ -262,7 +245,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -286,7 +269,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -303,7 +286,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -312,29 +295,16 @@ }, { "cell_type": "code", - "execution_count": 14, + "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()" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -350,7 +320,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -361,17 +331,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "observation_space= Discrete(6) action_space= Tuple(Discrete(2), Discrete(2), Discrete(5))\n" - ] - } - ], + "outputs": [], "source": [ "print(\"observation_space=\",env.observation_space, \"action_space=\",env.action_space)" ] @@ -409,7 +371,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ diff --git a/results/Analyse_result.ipynb b/results/Analyse_result.ipynb index a34f3d6..1b73be1 100644 --- a/results/Analyse_result.ipynb +++ b/results/Analyse_result.ipynb @@ -60,7 +60,7 @@ "metadata": {}, "outputs": [], "source": [ - "columns = [\"algo\",\"step_train\",\"batch_size\", \"gamma\", \"greedy_exploration\",\"network\",\"\", \"optimizer\", \"lr\", \"memories\", \"max_size\", \"step\", \"max\", \"min\", \"avg\", \"sum\"]" + "columns = [\"algo\",\"step_train\",\"batch_size\", \"gamma\", \"greedy_exploration\",\"network\",\"\", \"optimizer\", \"lr\", \"memories\", \"max_size\", \"TD_gamma\", \"step\", \"max\", \"min\", \"avg\", \"sum\"]" ] }, { @@ -128,6 +128,7 @@ " lr\n", " memories\n", " max_size\n", + " TD_gamma\n", " step\n", " sum\n", " \n", @@ -135,161 +136,171 @@ " \n", " \n", " 0\n", - " CategoricalDQN\n", + " DQN\n", " 1\n", " 32\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", - " C51Network\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", + " SimpleDuelingNetwork\n", " \n", " Adam\n", " 0.0001\n", " ExperienceReplay\n", " 2048\n", + " 0\n", " 1\n", - " 9.0\n", + " 10.0\n", " \n", " \n", " 1\n", - " CategoricalDQN\n", + " DQN\n", " 1\n", " 32\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", - " C51Network\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", + " SimpleDuelingNetwork\n", " \n", " Adam\n", " 0.0001\n", " ExperienceReplay\n", " 2048\n", + " 0\n", " 10\n", - " 10.0\n", + " 9.0\n", " \n", " \n", " 2\n", - " CategoricalDQN\n", + " DQN\n", " 1\n", " 32\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", - " C51Network\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", + " SimpleDuelingNetwork\n", " \n", " Adam\n", " 0.0001\n", " ExperienceReplay\n", " 2048\n", + " 0\n", " 20\n", - " 10.0\n", + " 9.0\n", " \n", " \n", " 3\n", - " CategoricalDQN\n", + " DQN\n", " 1\n", " 32\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", - " C51Network\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", + " SimpleDuelingNetwork\n", " \n", " Adam\n", " 0.0001\n", " ExperienceReplay\n", " 2048\n", + " 0\n", " 30\n", - " 9.0\n", + " 10.0\n", " \n", " \n", " 4\n", - " CategoricalDQN\n", + " DQN\n", " 1\n", " 32\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", - " C51Network\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", + " SimpleDuelingNetwork\n", " \n", " Adam\n", " 0.0001\n", " ExperienceReplay\n", " 2048\n", + " 0\n", " 40\n", - " 9.0\n", + " 10.0\n", " \n", " \n", " 5\n", - " CategoricalDQN\n", + " DQN\n", " 1\n", " 32\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", - " C51Network\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", + " SimpleDuelingNetwork\n", " \n", " Adam\n", " 0.0001\n", " ExperienceReplay\n", " 2048\n", + " 0\n", " 50\n", - " 8.0\n", + " 9.0\n", " \n", " \n", " 6\n", - " CategoricalDQN\n", + " DQN\n", " 1\n", " 32\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", - " C51Network\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", + " SimpleDuelingNetwork\n", " \n", " Adam\n", " 0.0001\n", " ExperienceReplay\n", " 2048\n", + " 0\n", " 60\n", - " 9.0\n", + " 10.0\n", " \n", " \n", " 7\n", - " CategoricalDQN\n", + " DQN\n", " 1\n", " 32\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", - " C51Network\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", + " SimpleDuelingNetwork\n", " \n", " Adam\n", " 0.0001\n", " ExperienceReplay\n", " 2048\n", + " 0\n", " 70\n", - " 10.0\n", + " 8.0\n", " \n", " \n", " 8\n", - " CategoricalDQN\n", + " DQN\n", " 1\n", " 32\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", - " C51Network\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", + " SimpleDuelingNetwork\n", " \n", " Adam\n", " 0.0001\n", " ExperienceReplay\n", " 2048\n", + " 0\n", " 80\n", - " 10.0\n", + " 11.0\n", " \n", " \n", " 9\n", - " CategoricalDQN\n", + " DQN\n", " 1\n", " 32\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", - " C51Network\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", + " SimpleDuelingNetwork\n", " \n", " Adam\n", " 0.0001\n", " ExperienceReplay\n", " 2048\n", + " 0\n", " 90\n", " 9.0\n", " \n", @@ -298,41 +309,29 @@ "" ], "text/plain": [ - " algo step_train batch_size gamma \\\n", - "0 CategoricalDQN 1 32 0.95 \n", - "1 CategoricalDQN 1 32 0.95 \n", - "2 CategoricalDQN 1 32 0.95 \n", - "3 CategoricalDQN 1 32 0.95 \n", - "4 CategoricalDQN 1 32 0.95 \n", - "5 CategoricalDQN 1 32 0.95 \n", - "6 CategoricalDQN 1 32 0.95 \n", - "7 CategoricalDQN 1 32 0.95 \n", - "8 CategoricalDQN 1 32 0.95 \n", - "9 CategoricalDQN 1 32 0.95 \n", - "\n", - " greedy_exploration network optimizer lr \\\n", - "0 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 C51Network Adam 0.0001 \n", - "1 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 C51Network Adam 0.0001 \n", - "2 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 C51Network Adam 0.0001 \n", - "3 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 C51Network Adam 0.0001 \n", - "4 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 C51Network Adam 0.0001 \n", - "5 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 C51Network Adam 0.0001 \n", - "6 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 C51Network Adam 0.0001 \n", - "7 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 C51Network Adam 0.0001 \n", - "8 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 C51Network Adam 0.0001 \n", - "9 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 C51Network Adam 0.0001 \n", + " algo step_train batch_size gamma greedy_exploration network \\\n", + "0 DQN 1 32 1.0 EpsilonGreedy-0.1 SimpleDuelingNetwork \n", + "1 DQN 1 32 1.0 EpsilonGreedy-0.1 SimpleDuelingNetwork \n", + "2 DQN 1 32 1.0 EpsilonGreedy-0.1 SimpleDuelingNetwork \n", + "3 DQN 1 32 1.0 EpsilonGreedy-0.1 SimpleDuelingNetwork \n", + "4 DQN 1 32 1.0 EpsilonGreedy-0.1 SimpleDuelingNetwork \n", + "5 DQN 1 32 1.0 EpsilonGreedy-0.1 SimpleDuelingNetwork \n", + "6 DQN 1 32 1.0 EpsilonGreedy-0.1 SimpleDuelingNetwork \n", + "7 DQN 1 32 1.0 EpsilonGreedy-0.1 SimpleDuelingNetwork \n", + "8 DQN 1 32 1.0 EpsilonGreedy-0.1 SimpleDuelingNetwork \n", + "9 DQN 1 32 1.0 EpsilonGreedy-0.1 SimpleDuelingNetwork \n", "\n", - " memories max_size step sum \n", - "0 ExperienceReplay 2048 1 9.0 \n", - "1 ExperienceReplay 2048 10 10.0 \n", - "2 ExperienceReplay 2048 20 10.0 \n", - "3 ExperienceReplay 2048 30 9.0 \n", - "4 ExperienceReplay 2048 40 9.0 \n", - "5 ExperienceReplay 2048 50 8.0 \n", - "6 ExperienceReplay 2048 60 9.0 \n", - "7 ExperienceReplay 2048 70 10.0 \n", - "8 ExperienceReplay 2048 80 10.0 \n", - "9 ExperienceReplay 2048 90 9.0 " + " optimizer lr memories max_size TD_gamma step sum \n", + "0 Adam 0.0001 ExperienceReplay 2048 0 1 10.0 \n", + "1 Adam 0.0001 ExperienceReplay 2048 0 10 9.0 \n", + "2 Adam 0.0001 ExperienceReplay 2048 0 20 9.0 \n", + "3 Adam 0.0001 ExperienceReplay 2048 0 30 10.0 \n", + "4 Adam 0.0001 ExperienceReplay 2048 0 40 10.0 \n", + "5 Adam 0.0001 ExperienceReplay 2048 0 50 9.0 \n", + "6 Adam 0.0001 ExperienceReplay 2048 0 60 10.0 \n", + "7 Adam 0.0001 ExperienceReplay 2048 0 70 8.0 \n", + "8 Adam 0.0001 ExperienceReplay 2048 0 80 11.0 \n", + "9 Adam 0.0001 ExperienceReplay 2048 0 90 9.0 " ] }, "execution_count": 8, @@ -357,7 +356,7 @@ "metadata": {}, "outputs": [], "source": [ - "for c in [\"step_train\", \"batch_size\", \"gamma\", \"lr\", \"step\", \"sum\"]:\n", + "for c in [\"step_train\", \"batch_size\", \"gamma\", \"lr\", \"step\", \"sum\", \"TD_gamma\"]:\n", " df[c] = df[c].astype(float)\n", "for c in df.columns:\n", " if df[c].dtypes == \"object\":\n", @@ -401,129 +400,137 @@ " lr\n", " memories\n", " max_size\n", + " TD_gamma\n", " step\n", " sum\n", " \n", " \n", " \n", " \n", - " 12340\n", - " DoubleDQN\n", + " 1683\n", + " DQN\n", " 1.0\n", " 32.0\n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", - " SimpleDuelingNetwork\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", + " SimpleNetwork\n", " \n", " Adam\n", - " 0.001\n", + " 0.100\n", " ExperienceReplay\n", - " 2048\n", - " 20.0\n", + " 512\n", + " 0.0\n", + " 50.0\n", " 500.0\n", " \n", " \n", - " 12930\n", - " DoubleDQN\n", + " 1436\n", + " DQN\n", " 1.0\n", " 32.0\n", - " 1.00\n", - " EpsilonGreedy-0.1\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", - " 512\n", - " 30.0\n", + " 2048\n", + " 0.0\n", + " 60.0\n", " 500.0\n", " \n", " \n", - " 31127\n", + " 1125\n", " DQN\n", " 1.0\n", " 32.0\n", - " 1.00\n", + " 1.0\n", " EpsilonGreedy-0.6\n", - " SimpleNetwork\n", + " SimpleDuelingNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 2048\n", - " 30.0\n", + " 0.0\n", + " 90.0\n", " 500.0\n", " \n", " \n", - " 31716\n", + " 1160\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleDuelingNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 30.0\n", + " 0.0\n", + " 90.0\n", " 500.0\n", " \n", " \n", - " 34103\n", + " 1126\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.99\n", + " 32.0\n", + " 1.0\n", " EpsilonGreedy-0.6\n", - " SimpleNetwork\n", + " SimpleDuelingNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 2048\n", - " 30.0\n", + " 0.0\n", + " 100.0\n", " 500.0\n", " \n", " \n", - " 11412\n", - " DoubleDQN\n", + " 1440\n", + " DQN\n", " 1.0\n", " 32.0\n", - " 0.99\n", - " EpsilonGreedy-0.1\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 2048\n", - " 40.0\n", + " 0.0\n", + " 100.0\n", " 500.0\n", " \n", " \n", - " 24122\n", - " DoubleDQN\n", + " 848\n", + " DQN\n", + " 1.0\n", " 32.0\n", - " 64.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.100\n", + " 0.001\n", " ExperienceReplay\n", - " 2048\n", - " 40.0\n", + " 512\n", + " 0.0\n", + " 110.0\n", " 500.0\n", " \n", " \n", - " 27997\n", + " 1162\n", " DQN\n", " 1.0\n", " 32.0\n", - " 0.95\n", + " 1.0\n", " EpsilonGreedy-0.6\n", " SimpleDuelingNetwork\n", " \n", @@ -531,39 +538,42 @@ " 0.001\n", " ExperienceReplay\n", " 512\n", - " 40.0\n", + " 0.0\n", + " 110.0\n", " 500.0\n", " \n", " \n", - " 29082\n", + " 849\n", " DQN\n", " 1.0\n", " 32.0\n", - " 0.99\n", + " 1.0\n", " EpsilonGreedy-0.1\n", - " SimpleDuelingNetwork\n", + " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", - " 2048\n", - " 40.0\n", + " 512\n", + " 0.0\n", + " 120.0\n", " 500.0\n", " \n", " \n", - " 30601\n", + " 1163\n", " DQN\n", " 1.0\n", " 32.0\n", - " 1.00\n", - " EpsilonGreedy-0.1\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleDuelingNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 40.0\n", + " 0.0\n", + " 120.0\n", " 500.0\n", " \n", " \n", @@ -571,41 +581,41 @@ "" ], "text/plain": [ - " algo step_train batch_size gamma \\\n", - "12340 DoubleDQN 1.0 32.0 1.00 \n", - "12930 DoubleDQN 1.0 32.0 1.00 \n", - "31127 DQN 1.0 32.0 1.00 \n", - "31716 DQN 1.0 64.0 0.95 \n", - "34103 DQN 1.0 64.0 0.99 \n", - "11412 DoubleDQN 1.0 32.0 0.99 \n", - "24122 DoubleDQN 32.0 64.0 0.99 \n", - "27997 DQN 1.0 32.0 0.95 \n", - "29082 DQN 1.0 32.0 0.99 \n", - "30601 DQN 1.0 32.0 1.00 \n", + " algo step_train batch_size gamma greedy_exploration \\\n", + "1683 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1436 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1125 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1160 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1126 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1440 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "848 DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 \n", + "1162 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "849 DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 \n", + "1163 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", "\n", - " greedy_exploration network \\\n", - "12340 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork \n", - "12930 EpsilonGreedy-0.1 SimpleNetwork \n", - "31127 EpsilonGreedy-0.6 SimpleNetwork \n", - "31716 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork \n", - "34103 EpsilonGreedy-0.6 SimpleNetwork \n", - "11412 EpsilonGreedy-0.1 SimpleNetwork \n", - "24122 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork \n", - "27997 EpsilonGreedy-0.6 SimpleDuelingNetwork \n", - "29082 EpsilonGreedy-0.1 SimpleDuelingNetwork \n", - "30601 EpsilonGreedy-0.1 SimpleDuelingNetwork \n", + " network optimizer lr memories max_size \\\n", + "1683 SimpleNetwork Adam 0.100 ExperienceReplay 512 \n", + "1436 SimpleNetwork Adam 0.001 ExperienceReplay 2048 \n", + "1125 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 \n", + "1160 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 512 \n", + "1126 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 \n", + "1440 SimpleNetwork Adam 0.001 ExperienceReplay 2048 \n", + "848 SimpleNetwork Adam 0.001 ExperienceReplay 512 \n", + "1162 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 512 \n", + "849 SimpleNetwork Adam 0.001 ExperienceReplay 512 \n", + "1163 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 512 \n", "\n", - " optimizer lr memories max_size step sum \n", - "12340 Adam 0.001 ExperienceReplay 2048 20.0 500.0 \n", - "12930 Adam 0.001 ExperienceReplay 512 30.0 500.0 \n", - "31127 Adam 0.001 ExperienceReplay 2048 30.0 500.0 \n", - "31716 Adam 0.001 ExperienceReplay 512 30.0 500.0 \n", - "34103 Adam 0.001 ExperienceReplay 2048 30.0 500.0 \n", - "11412 Adam 0.001 ExperienceReplay 2048 40.0 500.0 \n", - "24122 Adam 0.100 ExperienceReplay 2048 40.0 500.0 \n", - "27997 Adam 0.001 ExperienceReplay 512 40.0 500.0 \n", - "29082 Adam 0.001 ExperienceReplay 2048 40.0 500.0 \n", - "30601 Adam 0.001 ExperienceReplay 512 40.0 500.0 " + " TD_gamma step sum \n", + "1683 0.0 50.0 500.0 \n", + "1436 0.0 60.0 500.0 \n", + "1125 0.0 90.0 500.0 \n", + "1160 0.0 90.0 500.0 \n", + "1126 0.0 100.0 500.0 \n", + "1440 0.0 100.0 500.0 \n", + "848 0.0 110.0 500.0 \n", + "1162 0.0 110.0 500.0 \n", + "849 0.0 120.0 500.0 \n", + "1163 0.0 120.0 500.0 " ] }, "execution_count": 10, @@ -654,18 +664,19 @@ { "data": { "text/plain": [ - "algo 0.061506\n", - "step_train -0.314323\n", - "batch_size 0.044669\n", - "gamma -0.005792\n", - "greedy_exploration 0.017274\n", - "network 0.076661\n", + "algo NaN\n", + "step_train NaN\n", + "batch_size NaN\n", + "gamma NaN\n", + "greedy_exploration 0.258098\n", + "network 0.033773\n", " NaN\n", "optimizer NaN\n", - "lr -0.166335\n", + "lr -0.182324\n", "memories NaN\n", - "max_size -0.018768\n", - "step 0.161043\n", + "max_size 0.023941\n", + "TD_gamma -0.359880\n", + "step 0.127479\n", "sum 1.000000\n", "Name: sum, dtype: float64" ] @@ -696,7 +707,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -745,7 +756,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -829,33 +840,35 @@ " lr\n", " memories\n", " max_size\n", + " TD_gamma\n", " step\n", " sum\n", " \n", " \n", " \n", " \n", - " 31127\n", + " 1683\n", " DQN\n", " 1.0\n", " 32.0\n", - " 1.00\n", + " 1.0\n", " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.001\n", + " 0.100\n", " ExperienceReplay\n", - " 2048\n", - " 30.0\n", + " 512\n", + " 0.0\n", + " 50.0\n", " 500.0\n", " \n", " \n", - " 34103\n", + " 1436\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.99\n", + " 32.0\n", + " 1.0\n", " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", @@ -863,255 +876,271 @@ " 0.001\n", " ExperienceReplay\n", " 2048\n", - " 30.0\n", + " 0.0\n", + " 60.0\n", " 500.0\n", " \n", " \n", - " 33050\n", + " 1440\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.100\n", + " 0.001\n", " ExperienceReplay\n", " 2048\n", - " 40.0\n", + " 0.0\n", + " 100.0\n", " 500.0\n", " \n", " \n", - " 32648\n", + " 848\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.95\n", - " EpsilonGreedy-0.6\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 50.0\n", + " 0.0\n", + " 110.0\n", " 500.0\n", " \n", " \n", - " 34508\n", + " 849\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 50.0\n", + " 0.0\n", + " 120.0\n", " 500.0\n", " \n", " \n", - " 28898\n", + " 1442\n", " DQN\n", " 1.0\n", " 32.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 2048\n", - " 60.0\n", + " 0.0\n", + " 120.0\n", " 500.0\n", " \n", " \n", - " 33052\n", + " 1506\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.100\n", + " 0.001\n", " ExperienceReplay\n", - " 2048\n", - " 60.0\n", + " 512\n", + " 0.0\n", + " 140.0\n", " 500.0\n", " \n", " \n", - " 34943\n", + " 1447\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.100\n", + " 0.001\n", " ExperienceReplay\n", - " 512\n", - " 60.0\n", + " 2048\n", + " 0.0\n", + " 170.0\n", " 500.0\n", " \n", " \n", - " 35687\n", + " 1509\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 1.00\n", + " 32.0\n", + " 1.0\n", " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.100\n", + " 0.001\n", " ExperienceReplay\n", " 512\n", - " 60.0\n", + " 0.0\n", + " 170.0\n", " 500.0\n", " \n", " \n", - " 31906\n", + " 1450\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", - " 512\n", - " 70.0\n", + " 2048\n", + " 0.0\n", + " 200.0\n", " 500.0\n", " \n", " \n", - " 32991\n", + " 858\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", - " 2048\n", - " 70.0\n", + " 512\n", + " 0.0\n", + " 210.0\n", " 500.0\n", " \n", " \n", - " 34479\n", + " 1451\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 2048\n", - " 70.0\n", + " 0.0\n", + " 210.0\n", " 500.0\n", " \n", " \n", - " 28559\n", + " 1513\n", " DQN\n", " 1.0\n", " 32.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 80.0\n", + " 0.0\n", + " 210.0\n", " 500.0\n", " \n", " \n", - " 28993\n", + " 1452\n", " DQN\n", " 1.0\n", " 32.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.100\n", + " 0.001\n", " ExperienceReplay\n", - " 512\n", - " 80.0\n", + " 2048\n", + " 0.0\n", + " 220.0\n", " 500.0\n", " \n", " \n", - " 31163\n", + " 860\n", " DQN\n", " 1.0\n", " 32.0\n", - " 1.00\n", - " EpsilonGreedy-0.6\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 80.0\n", + " 0.0\n", + " 230.0\n", " 500.0\n", " \n", " \n", - " 31225\n", + " 861\n", " DQN\n", " 1.0\n", " 32.0\n", - " 1.00\n", - " EpsilonGreedy-0.6\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.100\n", + " 0.001\n", " ExperienceReplay\n", " 512\n", - " 80.0\n", + " 0.0\n", + " 240.0\n", " 500.0\n", " \n", " \n", - " 33798\n", + " 1454\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.99\n", - " EpsilonGreedy-0.1\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.100\n", + " 0.001\n", " ExperienceReplay\n", " 2048\n", - " 80.0\n", + " 0.0\n", + " 240.0\n", " 500.0\n", " \n", " \n", - " 35255\n", + " 862\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 1.00\n", + " 32.0\n", + " 1.0\n", " EpsilonGreedy-0.1\n", " SimpleNetwork\n", " \n", @@ -1119,681 +1148,662 @@ " 0.001\n", " ExperienceReplay\n", " 512\n", - " 80.0\n", + " 0.0\n", + " 250.0\n", " 500.0\n", " \n", " \n", - " 27072\n", + " 863\n", " DQN\n", " 1.0\n", " 32.0\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 90.0\n", + " 0.0\n", + " 260.0\n", " 500.0\n", " \n", " \n", - " 27785\n", + " 1456\n", " DQN\n", " 1.0\n", " 32.0\n", - " 0.95\n", - " EpsilonGreedy-0.1\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 2048\n", - " 90.0\n", + " 0.0\n", + " 260.0\n", " 500.0\n", " \n", " \n", - " 28188\n", + " 864\n", " DQN\n", " 1.0\n", " 32.0\n", - " 0.95\n", - " EpsilonGreedy-0.6\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 90.0\n", + " 0.0\n", + " 270.0\n", " 500.0\n", " \n", " \n", - " 31164\n", + " 865\n", " DQN\n", " 1.0\n", " 32.0\n", - " 1.00\n", - " EpsilonGreedy-0.6\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 90.0\n", + " 0.0\n", + " 280.0\n", " 500.0\n", " \n", " \n", - " 32714\n", + " 1458\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.95\n", + " 32.0\n", + " 1.0\n", " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.100\n", + " 0.001\n", " ExperienceReplay\n", - " 512\n", - " 90.0\n", + " 2048\n", + " 0.0\n", + " 280.0\n", " 500.0\n", " \n", " \n", - " 32993\n", + " 866\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", - " 2048\n", - " 90.0\n", + " 512\n", + " 0.0\n", + " 290.0\n", " 500.0\n", " \n", " \n", - " 33055\n", + " 1459\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.100\n", + " 0.001\n", " ExperienceReplay\n", " 2048\n", - " 90.0\n", + " 0.0\n", + " 290.0\n", " 500.0\n", " \n", " \n", - " 33768\n", + " 1521\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.99\n", - " EpsilonGreedy-0.1\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 90.0\n", + " 0.0\n", + " 290.0\n", " 500.0\n", " \n", " \n", - " 28561\n", + " 867\n", " DQN\n", " 1.0\n", " 32.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 100.0\n", + " 0.0\n", + " 300.0\n", " 500.0\n", " \n", " \n", - " 30390\n", + " 1449\n", " DQN\n", " 1.0\n", " 32.0\n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 2048\n", - " 100.0\n", - " 500.0\n", + " 0.0\n", + " 190.0\n", + " 490.0\n", " \n", " \n", - " 31134\n", + " 1501\n", " DQN\n", " 1.0\n", " 32.0\n", - " 1.00\n", + " 1.0\n", " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", - " 2048\n", - " 100.0\n", - " 500.0\n", + " 512\n", + " 0.0\n", + " 90.0\n", + " 454.0\n", " \n", " \n", - " 33025\n", + " 1520\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 100.0\n", - " 500.0\n", + " 0.0\n", + " 280.0\n", + " 454.0\n", " \n", " \n", - " 33397\n", + " 1507\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 100.0\n", - " 500.0\n", + " 0.0\n", + " 150.0\n", + " 449.0\n", " \n", " \n", - " 33428\n", + " 1453\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.100\n", + " 0.001\n", " ExperienceReplay\n", " 2048\n", - " 100.0\n", - " 500.0\n", + " 0.0\n", + " 230.0\n", + " 419.0\n", " \n", " \n", - " 27074\n", + " 1508\n", " DQN\n", " 1.0\n", " 32.0\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 110.0\n", - " 500.0\n", + " 0.0\n", + " 160.0\n", + " 412.0\n", " \n", " \n", - " 28562\n", + " 845\n", " DQN\n", " 1.0\n", " 32.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 110.0\n", - " 500.0\n", + " 0.0\n", + " 80.0\n", + " 407.0\n", " \n", " \n", - " 33026\n", + " 1460\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", - " 512\n", - " 110.0\n", - " 500.0\n", + " 2048\n", + " 0.0\n", + " 300.0\n", + " 397.0\n", " \n", " \n", - " 33367\n", + " 1695\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.001\n", + " 0.100\n", " ExperienceReplay\n", - " 2048\n", - " 110.0\n", - " 500.0\n", + " 512\n", + " 0.0\n", + " 170.0\n", + " 371.0\n", " \n", " \n", - " 34514\n", + " 1500\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 110.0\n", - " 500.0\n", + " 0.0\n", + " 80.0\n", + " 354.0\n", " \n", " \n", - " 35599\n", + " 1699\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 1.00\n", + " 32.0\n", + " 1.0\n", " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.001\n", + " 0.100\n", " ExperienceReplay\n", - " 2048\n", - " 110.0\n", - " 500.0\n", + " 512\n", + " 0.0\n", + " 210.0\n", + " 351.0\n", " \n", " \n", - " 27075\n", + " 1455\n", " DQN\n", " 1.0\n", " 32.0\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", - " 512\n", - " 120.0\n", - " 500.0\n", + " 2048\n", + " 0.0\n", + " 250.0\n", + " 329.0\n", " \n", " \n", - " 28563\n", + " 1518\n", " DQN\n", " 1.0\n", " 32.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 512\n", - " 120.0\n", - " 500.0\n", + " 0.0\n", + " 260.0\n", + " 325.0\n", " \n", " \n", - " 30020\n", + " 1448\n", " DQN\n", " 1.0\n", " 32.0\n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 2048\n", - " 120.0\n", - " 500.0\n", + " 0.0\n", + " 180.0\n", + " 323.0\n", " \n", " \n", - " 30423\n", + " 1457\n", " DQN\n", " 1.0\n", " 32.0\n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", - " 512\n", - " 120.0\n", - " 500.0\n", + " 2048\n", + " 0.0\n", + " 270.0\n", + " 317.0\n", " \n", " \n", - " 31136\n", + " 1516\n", " DQN\n", " 1.0\n", " 32.0\n", - " 1.00\n", + " 1.0\n", " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", - " 2048\n", - " 120.0\n", - " 500.0\n", + " 512\n", + " 0.0\n", + " 240.0\n", + " 308.0\n", " \n", " \n", - " 31167\n", + " 1700\n", " DQN\n", " 1.0\n", " 32.0\n", - " 1.00\n", + " 1.0\n", " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.001\n", + " 0.100\n", " ExperienceReplay\n", " 512\n", - " 120.0\n", - " 500.0\n", + " 0.0\n", + " 220.0\n", + " 302.0\n", " \n", " \n", - " 31911\n", + " 1446\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", - " 512\n", - " 120.0\n", - " 500.0\n", + " 2048\n", + " 0.0\n", + " 160.0\n", + " 296.0\n", " \n", " \n", - " 34112\n", + " 847\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 0.99\n", - " EpsilonGreedy-0.6\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.1\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", - " 2048\n", - " 120.0\n", - " 500.0\n", + " 512\n", + " 0.0\n", + " 100.0\n", + " 295.0\n", " \n", " \n", - " 34856\n", + " 1441\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", " 2048\n", - " 120.0\n", - " 500.0\n", + " 0.0\n", + " 110.0\n", + " 293.0\n", " \n", " \n", - " 35259\n", + " 1687\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 1.00\n", - " EpsilonGreedy-0.1\n", + " 32.0\n", + " 1.0\n", + " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.001\n", + " 0.100\n", " ExperienceReplay\n", " 512\n", - " 120.0\n", - " 500.0\n", + " 0.0\n", + " 90.0\n", + " 288.0\n", " \n", " \n", - " 35693\n", + " 1499\n", " DQN\n", " 1.0\n", - " 64.0\n", - " 1.00\n", + " 32.0\n", + " 1.0\n", " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", - " 0.100\n", + " 0.001\n", " ExperienceReplay\n", " 512\n", - " 120.0\n", - " 500.0\n", + " 0.0\n", + " 70.0\n", + " 287.0\n", " \n", " \n", - " 28192\n", + " 1439\n", " DQN\n", " 1.0\n", " 32.0\n", - " 0.95\n", + " 1.0\n", " EpsilonGreedy-0.6\n", " SimpleNetwork\n", " \n", " Adam\n", " 0.001\n", " ExperienceReplay\n", - " 512\n", - " 130.0\n", - " 500.0\n", + " 2048\n", + " 0.0\n", + " 90.0\n", + " 280.0\n", " \n", " \n", "\n", "" ], "text/plain": [ - " algo step_train batch_size gamma \\\n", - "31127 DQN 1.0 32.0 1.00 \n", - "34103 DQN 1.0 64.0 0.99 \n", - "33050 DQN 1.0 64.0 0.99 \n", - "32648 DQN 1.0 64.0 0.95 \n", - "34508 DQN 1.0 64.0 1.00 \n", - "28898 DQN 1.0 32.0 0.99 \n", - "33052 DQN 1.0 64.0 0.99 \n", - "34943 DQN 1.0 64.0 1.00 \n", - "35687 DQN 1.0 64.0 1.00 \n", - "31906 DQN 1.0 64.0 0.95 \n", - "32991 DQN 1.0 64.0 0.99 \n", - "34479 DQN 1.0 64.0 1.00 \n", - "28559 DQN 1.0 32.0 0.99 \n", - "28993 DQN 1.0 32.0 0.99 \n", - "31163 DQN 1.0 32.0 1.00 \n", - "31225 DQN 1.0 32.0 1.00 \n", - "33798 DQN 1.0 64.0 0.99 \n", - "35255 DQN 1.0 64.0 1.00 \n", - "27072 DQN 1.0 32.0 0.95 \n", - "27785 DQN 1.0 32.0 0.95 \n", - "28188 DQN 1.0 32.0 0.95 \n", - "31164 DQN 1.0 32.0 1.00 \n", - "32714 DQN 1.0 64.0 0.95 \n", - "32993 DQN 1.0 64.0 0.99 \n", - "33055 DQN 1.0 64.0 0.99 \n", - "33768 DQN 1.0 64.0 0.99 \n", - "28561 DQN 1.0 32.0 0.99 \n", - "30390 DQN 1.0 32.0 1.00 \n", - "31134 DQN 1.0 32.0 1.00 \n", - "33025 DQN 1.0 64.0 0.99 \n", - "33397 DQN 1.0 64.0 0.99 \n", - "33428 DQN 1.0 64.0 0.99 \n", - "27074 DQN 1.0 32.0 0.95 \n", - "28562 DQN 1.0 32.0 0.99 \n", - "33026 DQN 1.0 64.0 0.99 \n", - "33367 DQN 1.0 64.0 0.99 \n", - "34514 DQN 1.0 64.0 1.00 \n", - "35599 DQN 1.0 64.0 1.00 \n", - "27075 DQN 1.0 32.0 0.95 \n", - "28563 DQN 1.0 32.0 0.99 \n", - "30020 DQN 1.0 32.0 1.00 \n", - "30423 DQN 1.0 32.0 1.00 \n", - "31136 DQN 1.0 32.0 1.00 \n", - "31167 DQN 1.0 32.0 1.00 \n", - "31911 DQN 1.0 64.0 0.95 \n", - "34112 DQN 1.0 64.0 0.99 \n", - "34856 DQN 1.0 64.0 1.00 \n", - "35259 DQN 1.0 64.0 1.00 \n", - "35693 DQN 1.0 64.0 1.00 \n", - "28192 DQN 1.0 32.0 0.95 \n", - "\n", - " greedy_exploration network optimizer \\\n", - "31127 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "34103 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "33050 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "32648 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "34508 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "28898 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam \n", - "33052 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "34943 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam \n", - "35687 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "31906 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam \n", - "32991 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "34479 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "28559 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "28993 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam \n", - "31163 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "31225 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "33798 EpsilonGreedy-0.1 SimpleNetwork Adam \n", - "35255 EpsilonGreedy-0.1 SimpleNetwork Adam \n", - "27072 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "27785 EpsilonGreedy-0.1 SimpleNetwork Adam \n", - "28188 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "31164 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "32714 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "32993 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "33055 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "33768 EpsilonGreedy-0.1 SimpleNetwork Adam \n", - "28561 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "30390 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam \n", - "31134 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "33025 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "33397 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam \n", - "33428 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam \n", - "27074 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "28562 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "33026 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "33367 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam \n", - "34514 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "35599 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "27075 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "28563 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "30020 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "30423 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam \n", - "31136 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "31167 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "31911 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam \n", - "34112 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "34856 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam \n", - "35259 EpsilonGreedy-0.1 SimpleNetwork Adam \n", - "35693 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "28192 EpsilonGreedy-0.6 SimpleNetwork Adam \n", + " algo step_train batch_size gamma greedy_exploration network \\\n", + "1683 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1436 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1440 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "848 DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 SimpleNetwork \n", + "849 DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 SimpleNetwork \n", + "1442 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1506 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1447 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1509 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1450 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "858 DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 SimpleNetwork \n", + "1451 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1513 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1452 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "860 DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 SimpleNetwork \n", + "861 DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 SimpleNetwork \n", + "1454 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "862 DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 SimpleNetwork \n", + "863 DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 SimpleNetwork \n", + "1456 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "864 DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 SimpleNetwork \n", + "865 DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 SimpleNetwork \n", + "1458 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "866 DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 SimpleNetwork \n", + "1459 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1521 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "867 DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 SimpleNetwork \n", + "1449 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1501 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1520 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1507 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1453 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1508 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "845 DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 SimpleNetwork \n", + "1460 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1695 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1500 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1699 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1455 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1518 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1448 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1457 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1516 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1700 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1446 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "847 DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 SimpleNetwork \n", + "1441 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1687 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1499 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", + "1439 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleNetwork \n", "\n", - " lr memories max_size step sum \n", - "31127 0.001 ExperienceReplay 2048 30.0 500.0 \n", - "34103 0.001 ExperienceReplay 2048 30.0 500.0 \n", - "33050 0.100 ExperienceReplay 2048 40.0 500.0 \n", - "32648 0.001 ExperienceReplay 512 50.0 500.0 \n", - "34508 0.001 ExperienceReplay 512 50.0 500.0 \n", - "28898 0.001 ExperienceReplay 2048 60.0 500.0 \n", - "33052 0.100 ExperienceReplay 2048 60.0 500.0 \n", - "34943 0.100 ExperienceReplay 512 60.0 500.0 \n", - "35687 0.100 ExperienceReplay 512 60.0 500.0 \n", - "31906 0.001 ExperienceReplay 512 70.0 500.0 \n", - "32991 0.001 ExperienceReplay 2048 70.0 500.0 \n", - "34479 0.001 ExperienceReplay 2048 70.0 500.0 \n", - "28559 0.001 ExperienceReplay 512 80.0 500.0 \n", - "28993 0.100 ExperienceReplay 512 80.0 500.0 \n", - "31163 0.001 ExperienceReplay 512 80.0 500.0 \n", - "31225 0.100 ExperienceReplay 512 80.0 500.0 \n", - "33798 0.100 ExperienceReplay 2048 80.0 500.0 \n", - "35255 0.001 ExperienceReplay 512 80.0 500.0 \n", - "27072 0.001 ExperienceReplay 512 90.0 500.0 \n", - "27785 0.001 ExperienceReplay 2048 90.0 500.0 \n", - "28188 0.001 ExperienceReplay 512 90.0 500.0 \n", - "31164 0.001 ExperienceReplay 512 90.0 500.0 \n", - "32714 0.100 ExperienceReplay 512 90.0 500.0 \n", - "32993 0.001 ExperienceReplay 2048 90.0 500.0 \n", - "33055 0.100 ExperienceReplay 2048 90.0 500.0 \n", - "33768 0.001 ExperienceReplay 512 90.0 500.0 \n", - "28561 0.001 ExperienceReplay 512 100.0 500.0 \n", - "30390 0.001 ExperienceReplay 2048 100.0 500.0 \n", - "31134 0.001 ExperienceReplay 2048 100.0 500.0 \n", - "33025 0.001 ExperienceReplay 512 100.0 500.0 \n", - "33397 0.001 ExperienceReplay 512 100.0 500.0 \n", - "33428 0.100 ExperienceReplay 2048 100.0 500.0 \n", - "27074 0.001 ExperienceReplay 512 110.0 500.0 \n", - "28562 0.001 ExperienceReplay 512 110.0 500.0 \n", - "33026 0.001 ExperienceReplay 512 110.0 500.0 \n", - "33367 0.001 ExperienceReplay 2048 110.0 500.0 \n", - "34514 0.001 ExperienceReplay 512 110.0 500.0 \n", - "35599 0.001 ExperienceReplay 2048 110.0 500.0 \n", - "27075 0.001 ExperienceReplay 512 120.0 500.0 \n", - "28563 0.001 ExperienceReplay 512 120.0 500.0 \n", - "30020 0.001 ExperienceReplay 2048 120.0 500.0 \n", - "30423 0.001 ExperienceReplay 512 120.0 500.0 \n", - "31136 0.001 ExperienceReplay 2048 120.0 500.0 \n", - "31167 0.001 ExperienceReplay 512 120.0 500.0 \n", - "31911 0.001 ExperienceReplay 512 120.0 500.0 \n", - "34112 0.001 ExperienceReplay 2048 120.0 500.0 \n", - "34856 0.001 ExperienceReplay 2048 120.0 500.0 \n", - "35259 0.001 ExperienceReplay 512 120.0 500.0 \n", - "35693 0.100 ExperienceReplay 512 120.0 500.0 \n", - "28192 0.001 ExperienceReplay 512 130.0 500.0 " + " optimizer lr memories max_size TD_gamma step sum \n", + "1683 Adam 0.100 ExperienceReplay 512 0.0 50.0 500.0 \n", + "1436 Adam 0.001 ExperienceReplay 2048 0.0 60.0 500.0 \n", + "1440 Adam 0.001 ExperienceReplay 2048 0.0 100.0 500.0 \n", + "848 Adam 0.001 ExperienceReplay 512 0.0 110.0 500.0 \n", + "849 Adam 0.001 ExperienceReplay 512 0.0 120.0 500.0 \n", + "1442 Adam 0.001 ExperienceReplay 2048 0.0 120.0 500.0 \n", + "1506 Adam 0.001 ExperienceReplay 512 0.0 140.0 500.0 \n", + "1447 Adam 0.001 ExperienceReplay 2048 0.0 170.0 500.0 \n", + "1509 Adam 0.001 ExperienceReplay 512 0.0 170.0 500.0 \n", + "1450 Adam 0.001 ExperienceReplay 2048 0.0 200.0 500.0 \n", + "858 Adam 0.001 ExperienceReplay 512 0.0 210.0 500.0 \n", + "1451 Adam 0.001 ExperienceReplay 2048 0.0 210.0 500.0 \n", + "1513 Adam 0.001 ExperienceReplay 512 0.0 210.0 500.0 \n", + "1452 Adam 0.001 ExperienceReplay 2048 0.0 220.0 500.0 \n", + "860 Adam 0.001 ExperienceReplay 512 0.0 230.0 500.0 \n", + "861 Adam 0.001 ExperienceReplay 512 0.0 240.0 500.0 \n", + "1454 Adam 0.001 ExperienceReplay 2048 0.0 240.0 500.0 \n", + "862 Adam 0.001 ExperienceReplay 512 0.0 250.0 500.0 \n", + "863 Adam 0.001 ExperienceReplay 512 0.0 260.0 500.0 \n", + "1456 Adam 0.001 ExperienceReplay 2048 0.0 260.0 500.0 \n", + "864 Adam 0.001 ExperienceReplay 512 0.0 270.0 500.0 \n", + "865 Adam 0.001 ExperienceReplay 512 0.0 280.0 500.0 \n", + "1458 Adam 0.001 ExperienceReplay 2048 0.0 280.0 500.0 \n", + "866 Adam 0.001 ExperienceReplay 512 0.0 290.0 500.0 \n", + "1459 Adam 0.001 ExperienceReplay 2048 0.0 290.0 500.0 \n", + "1521 Adam 0.001 ExperienceReplay 512 0.0 290.0 500.0 \n", + "867 Adam 0.001 ExperienceReplay 512 0.0 300.0 500.0 \n", + "1449 Adam 0.001 ExperienceReplay 2048 0.0 190.0 490.0 \n", + "1501 Adam 0.001 ExperienceReplay 512 0.0 90.0 454.0 \n", + "1520 Adam 0.001 ExperienceReplay 512 0.0 280.0 454.0 \n", + "1507 Adam 0.001 ExperienceReplay 512 0.0 150.0 449.0 \n", + "1453 Adam 0.001 ExperienceReplay 2048 0.0 230.0 419.0 \n", + "1508 Adam 0.001 ExperienceReplay 512 0.0 160.0 412.0 \n", + "845 Adam 0.001 ExperienceReplay 512 0.0 80.0 407.0 \n", + "1460 Adam 0.001 ExperienceReplay 2048 0.0 300.0 397.0 \n", + "1695 Adam 0.100 ExperienceReplay 512 0.0 170.0 371.0 \n", + "1500 Adam 0.001 ExperienceReplay 512 0.0 80.0 354.0 \n", + "1699 Adam 0.100 ExperienceReplay 512 0.0 210.0 351.0 \n", + "1455 Adam 0.001 ExperienceReplay 2048 0.0 250.0 329.0 \n", + "1518 Adam 0.001 ExperienceReplay 512 0.0 260.0 325.0 \n", + "1448 Adam 0.001 ExperienceReplay 2048 0.0 180.0 323.0 \n", + "1457 Adam 0.001 ExperienceReplay 2048 0.0 270.0 317.0 \n", + "1516 Adam 0.001 ExperienceReplay 512 0.0 240.0 308.0 \n", + "1700 Adam 0.100 ExperienceReplay 512 0.0 220.0 302.0 \n", + "1446 Adam 0.001 ExperienceReplay 2048 0.0 160.0 296.0 \n", + "847 Adam 0.001 ExperienceReplay 512 0.0 100.0 295.0 \n", + "1441 Adam 0.001 ExperienceReplay 2048 0.0 110.0 293.0 \n", + "1687 Adam 0.100 ExperienceReplay 512 0.0 90.0 288.0 \n", + "1499 Adam 0.001 ExperienceReplay 512 0.0 70.0 287.0 \n", + "1439 Adam 0.001 ExperienceReplay 2048 0.0 90.0 280.0 " ] }, "execution_count": 18, @@ -1822,7 +1832,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1874,6 +1884,7 @@ " \n", " \n", " \n", + " \n", " step\n", " sum\n", " \n", @@ -1888,6 +1899,7 @@ " lr\n", " memories\n", " max_size\n", + " TD_gamma\n", " \n", " \n", " \n", @@ -1895,729 +1907,709 @@ " \n", " \n", " \n", - " DQN\n", - " 1.0\n", - " 32.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", - " SimpleNetwork\n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 512\n", - " 17\n", - " 17\n", - " 17\n", - " \n", - " \n", - " 64.0\n", - " 1.00\n", + " DQN\n", + " 1.0\n", + " 32.0\n", + " 1.0\n", " EpsilonGreedy-0.1\n", " SimpleNetwork\n", " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 512\n", - " 14\n", - " 14\n", - " 14\n", - " \n", - " \n", - " 32.0\n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", - " SimpleNetwork\n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " 10\n", - " 10\n", - " 10\n", - " \n", - " \n", - " 64.0\n", - " 1.00\n", - " EpsilonGreedy-0.6\n", - " SimpleNetwork\n", - " Adam\n", - " 0.1000\n", - " ExperienceReplay\n", - " 512\n", - " 9\n", - " 9\n", - " 9\n", - " \n", - " \n", - " 0.99\n", - " EpsilonGreedy-0.6\n", - " SimpleNetwork\n", - " Adam\n", - " 0.1000\n", + " 0.001\n", " ExperienceReplay\n", " 512\n", - " 9\n", - " 9\n", - " 9\n", - " \n", - " \n", - " 32.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", - " SimpleNetwork\n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " 8\n", - " 8\n", - " 8\n", - " \n", - " \n", - " 1.00\n", - " EpsilonGreedy-0.6\n", - " SimpleNetwork\n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " 8\n", - " 8\n", - " 8\n", - " \n", - " \n", - " 64.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", - " SimpleNetwork\n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " 8\n", - " 8\n", - " 8\n", + " 0.0\n", + " 11\n", + " 11\n", + " 11\n", " \n", " \n", - " 1.00\n", - " EpsilonGreedy-0.6\n", - " SimpleNetwork\n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", + " EpsilonGreedy-0.6\n", + " SimpleNetwork\n", + " Adam\n", + " 0.001\n", + " ExperienceReplay\n", " 2048\n", - " 7\n", - " 7\n", - " 7\n", - " \n", - " \n", - " 0.99\n", - " EpsilonGreedy-0.6\n", - " SimpleNetwork\n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 512\n", - " 6\n", - " 6\n", - " 6\n", + " 0.0\n", + " 11\n", + " 11\n", + " 11\n", " \n", " \n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", - " SimpleNetwork\n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", " 512\n", - " 5\n", - " 5\n", - " 5\n", + " 0.0\n", + " 4\n", + " 4\n", + " 4\n", " \n", " \n", - " 32.0\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", - " SimpleNetwork\n", - " Adam\n", - " 0.0010\n", + " 0.100\n", " ExperienceReplay\n", " 512\n", - " 5\n", - " 5\n", - " 5\n", - " \n", - " \n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", - " SimpleNetwork\n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " 5\n", - " 5\n", - " 5\n", + " 0.0\n", + " 1\n", + " 1\n", + " 1\n", " \n", - " \n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", - " SimpleNetwork\n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " 5\n", - " 5\n", - " 5\n", - " \n", - " \n", - " 64.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", - " SimpleNetwork\n", - " Adam\n", - " 0.1000\n", - " ExperienceReplay\n", - " 2048\n", - " 5\n", - " 5\n", - " 5\n", + " \n", + "\n", + "" + ], + "text/plain": [ + " \\\n", + "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size TD_gamma \n", + "DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 SimpleNetwork Adam 0.001 ExperienceReplay 512 0.0 11 \n", + " EpsilonGreedy-0.6 SimpleNetwork Adam 0.001 ExperienceReplay 2048 0.0 11 \n", + " 512 0.0 4 \n", + " 0.100 ExperienceReplay 512 0.0 1 \n", + "\n", + " step \\\n", + "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size TD_gamma \n", + "DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 SimpleNetwork Adam 0.001 ExperienceReplay 512 0.0 11 \n", + " EpsilonGreedy-0.6 SimpleNetwork Adam 0.001 ExperienceReplay 2048 0.0 11 \n", + " 512 0.0 4 \n", + " 0.100 ExperienceReplay 512 0.0 1 \n", + "\n", + " sum \n", + "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size TD_gamma \n", + "DQN 1.0 32.0 1.0 EpsilonGreedy-0.1 SimpleNetwork Adam 0.001 ExperienceReplay 512 0.0 11 \n", + " EpsilonGreedy-0.6 SimpleNetwork Adam 0.001 ExperienceReplay 2048 0.0 11 \n", + " 512 0.0 4 \n", + " 0.100 ExperienceReplay 512 0.0 1 " + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "columns = [\"algo\",\"step_train\",\"batch_size\",\"gamma\",\"greedy_exploration\",\"network\",\"optimizer\",\"lr\",\"memories\",\"max_size\",\"TD_gamma\"]\n", + "df_DQN[df_DQN[\"sum\"] >= 500].groupby(by=columns, observed=True).count().sort_values(by=['sum'], ascending=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### DuelingNetwork" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "df_DQN = df[df[\"algo\"] == \"DQN\"].copy()\n", + "df_DQN = df_DQN[df_DQN[\"network\"] == \"SimpleDuelingNetwork\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + "
algostep_trainbatch_sizegammagreedy_explorationnetworkoptimizerlrmemoriesmax_sizeTD_gammastepsum
1.00AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleNetworkAdam0.0010ExperienceReplay20484441125DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay20480.090.0500.0
AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleNetworkAdam0.0010ExperienceReplay5124441160DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay5120.090.0500.0
0.99EpsilonGreedy-0.6SimpleNetworkAdam0.0010ExperienceReplay20484441126DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay20480.0100.0500.0
0.95EpsilonGreedy-0.6SimpleNetworkAdam0.1000ExperienceReplay5124441162DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay5120.0110.0500.0
AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleNetworkAdam0.0010ExperienceReplay5124441163DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay5120.0120.0500.0
20484441130DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay20480.0140.0500.0
32.00.95EpsilonGreedy-0.6SimpleNetworkAdam0.0010ExperienceReplay5124441165DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay5120.0140.0500.0
1.00EpsilonGreedy-0.6SimpleNetworkAdam0.0010ExperienceReplay5124441167DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay5120.0160.0500.0
0.95AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleNetworkAdam0.0010ExperienceReplay20483331170DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay5120.0190.0500.0
64.00.99EpsilonGreedy-0.1SimpleNetworkAdam0.1000ExperienceReplay2048333
32.00.95EpsilonGreedy-0.1SimpleNetworkAdam0.0010ExperienceReplay2048333
1.00EpsilonGreedy-0.6SimpleNetworkAdam0.1000ExperienceReplay512333
64.01.00AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleNetworkAdam0.0010ExperienceReplay2048333
AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleNetworkAdam0.1000ExperienceReplay512222
32.00.99AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleNetworkAdam0.1000ExperienceReplay512222
EpsilonGreedy-0.6SimpleNetworkAdam0.0010ExperienceReplay512222
64.00.95AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleNetworkAdam0.0010ExperienceReplay5122221136DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay20480.0200.0500.0
0.99AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleNetworkAdam0.0010ExperienceReplay5122221137DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay20480.0210.0500.0
0.95AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleNetworkAdam0.0001ExperienceReplay20482221138DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay20480.0220.0500.0
0.99EpsilonGreedy-0.1SimpleNetworkAdam0.0010ExperienceReplay5122221139DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay20480.0230.0500.0
AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleNetworkAdam0.0010ExperienceReplay5121111140DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay20480.0240.0500.0
0.1000ExperienceReplay20481111141DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay20480.0250.0500.0
0.95AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleNetworkAdam0.0001ExperienceReplay20481111176DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay5120.0250.0500.0
0.99AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleNetworkAdam0.0010ExperienceReplay20481111142DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay20480.0260.0500.0
32.01.00EpsilonGreedy-0.1SimpleNetworkAdam0.0010ExperienceReplay20481111177DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay5120.0260.0500.0
AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleNetworkAdam0.0010ExperienceReplay5121111143DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay20480.0270.0500.0
EpsilonGreedy-0.1SimpleNetworkAdam0.0010ExperienceReplay5121111144DQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay20480.0280.0500.0
0.99EpsilonGreedy-0.1SimpleNetworkAdam0.0010ExperienceReplay512111
\n", + "
" + ], + "text/plain": [ + " algo step_train batch_size gamma greedy_exploration \\\n", + "1125 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1160 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1126 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1162 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1163 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1130 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1165 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1167 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1170 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1136 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1137 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1138 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1139 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1140 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1141 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1176 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1142 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1177 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1143 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "1144 DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 \n", + "\n", + " network optimizer lr memories max_size \\\n", + "1125 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 \n", + "1160 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 512 \n", + "1126 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 \n", + "1162 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 512 \n", + "1163 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 512 \n", + "1130 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 \n", + "1165 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 512 \n", + "1167 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 512 \n", + "1170 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 512 \n", + "1136 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 \n", + "1137 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 \n", + "1138 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 \n", + "1139 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 \n", + "1140 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 \n", + "1141 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 \n", + "1176 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 512 \n", + "1142 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 \n", + "1177 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 512 \n", + "1143 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 \n", + "1144 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 \n", + "\n", + " TD_gamma step sum \n", + "1125 0.0 90.0 500.0 \n", + "1160 0.0 90.0 500.0 \n", + "1126 0.0 100.0 500.0 \n", + "1162 0.0 110.0 500.0 \n", + "1163 0.0 120.0 500.0 \n", + "1130 0.0 140.0 500.0 \n", + "1165 0.0 140.0 500.0 \n", + "1167 0.0 160.0 500.0 \n", + "1170 0.0 190.0 500.0 \n", + "1136 0.0 200.0 500.0 \n", + "1137 0.0 210.0 500.0 \n", + "1138 0.0 220.0 500.0 \n", + "1139 0.0 230.0 500.0 \n", + "1140 0.0 240.0 500.0 \n", + "1141 0.0 250.0 500.0 \n", + "1176 0.0 250.0 500.0 \n", + "1142 0.0 260.0 500.0 \n", + "1177 0.0 260.0 500.0 \n", + "1143 0.0 270.0 500.0 \n", + "1144 0.0 280.0 500.0 " + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_DQN.sort_values(by =[\"sum\",\"step\"], ascending = [False, True]).head(20)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(10,10)) \n", + "sns.heatmap(df_DQN.corr()[abs(df_DQN.corr()) > 0.05], annot = True, fmt='.2g',cmap= 'coolwarm', ax=ax)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", "
stepsum
64.00.95EpsilonGreedy-0.6SimpleNetworkAdam0.0010ExperienceReplay512111algostep_trainbatch_sizegammagreedy_explorationnetworkoptimizerlrmemoriesmax_sizeTD_gamma
0.0001ExperienceReplayDQN1.032.01.0EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay2048111
AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleNetworkAdam0.0001ExperienceReplay5121110.0131313
32.00.95AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleNetworkAdam0.0010ExperienceReplay5121110.0888
\n", "
" ], "text/plain": [ - " \\\n", - "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size \n", - "DQN 1.0 32.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 17 \n", - " 64.0 1.00 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 14 \n", - " 32.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 10 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.1000 ExperienceReplay 512 9 \n", - " 0.99 EpsilonGreedy-0.6 SimpleNetwork Adam 0.1000 ExperienceReplay 512 9 \n", - " 32.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 8 \n", - " 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 8 \n", - " 64.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 8 \n", - " 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 7 \n", - " 0.99 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 512 6 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 5 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 5 \n", - " 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 5 \n", - " 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 5 \n", - " 64.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 2048 5 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 0.99 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " 0.95 EpsilonGreedy-0.6 SimpleNetwork Adam 0.1000 ExperienceReplay 512 4 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 2048 4 \n", - " 32.0 0.95 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " 64.0 0.99 EpsilonGreedy-0.1 SimpleNetwork Adam 0.1000 ExperienceReplay 2048 3 \n", - " 32.0 0.95 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.1000 ExperienceReplay 512 3 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 512 2 \n", - " 32.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 512 2 \n", - " EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0001 ExperienceReplay 2048 2 \n", - " 0.99 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 0.1000 ExperienceReplay 2048 1 \n", - " 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 32.0 1.00 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 0.99 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 64.0 0.95 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 0.0001 ExperienceReplay 2048 1 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", + " \\\n", + "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size TD_gamma \n", + "DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 0.0 13 \n", + " 512 0.0 8 \n", "\n", - " step \\\n", - "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size \n", - "DQN 1.0 32.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 17 \n", - " 64.0 1.00 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 14 \n", - " 32.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 10 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.1000 ExperienceReplay 512 9 \n", - " 0.99 EpsilonGreedy-0.6 SimpleNetwork Adam 0.1000 ExperienceReplay 512 9 \n", - " 32.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 8 \n", - " 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 8 \n", - " 64.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 8 \n", - " 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 7 \n", - " 0.99 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 512 6 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 5 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 5 \n", - " 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 5 \n", - " 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 5 \n", - " 64.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 2048 5 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 0.99 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " 0.95 EpsilonGreedy-0.6 SimpleNetwork Adam 0.1000 ExperienceReplay 512 4 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 2048 4 \n", - " 32.0 0.95 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " 64.0 0.99 EpsilonGreedy-0.1 SimpleNetwork Adam 0.1000 ExperienceReplay 2048 3 \n", - " 32.0 0.95 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.1000 ExperienceReplay 512 3 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 512 2 \n", - " 32.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 512 2 \n", - " EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0001 ExperienceReplay 2048 2 \n", - " 0.99 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 0.1000 ExperienceReplay 2048 1 \n", - " 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 32.0 1.00 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 0.99 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 64.0 0.95 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 0.0001 ExperienceReplay 2048 1 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", + " step \\\n", + "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size TD_gamma \n", + "DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 0.0 13 \n", + " 512 0.0 8 \n", "\n", - " sum \n", - "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size \n", - "DQN 1.0 32.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 17 \n", - " 64.0 1.00 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 14 \n", - " 32.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 10 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.1000 ExperienceReplay 512 9 \n", - " 0.99 EpsilonGreedy-0.6 SimpleNetwork Adam 0.1000 ExperienceReplay 512 9 \n", - " 32.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 8 \n", - " 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 8 \n", - " 64.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 8 \n", - " 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 7 \n", - " 0.99 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 512 6 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 5 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 5 \n", - " 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 5 \n", - " 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 5 \n", - " 64.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 2048 5 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 0.99 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " 0.95 EpsilonGreedy-0.6 SimpleNetwork Adam 0.1000 ExperienceReplay 512 4 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 2048 4 \n", - " 32.0 0.95 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " 64.0 0.99 EpsilonGreedy-0.1 SimpleNetwork Adam 0.1000 ExperienceReplay 2048 3 \n", - " 32.0 0.95 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.1000 ExperienceReplay 512 3 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 512 2 \n", - " 32.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 512 2 \n", - " EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0001 ExperienceReplay 2048 2 \n", - " 0.99 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 0.1000 ExperienceReplay 2048 1 \n", - " 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 32.0 1.00 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 0.99 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 64.0 0.95 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 0.0001 ExperienceReplay 2048 1 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 " + " sum \n", + "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size TD_gamma \n", + "DQN 1.0 32.0 1.0 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.001 ExperienceReplay 2048 0.0 13 \n", + " 512 0.0 8 " ] }, - "execution_count": 20, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "columns = [\"algo\",\"step_train\",\"batch_size\",\"gamma\",\"greedy_exploration\",\"network\",\"optimizer\",\"lr\",\"memories\",\"max_size\"]\n", + "columns = [\"algo\",\"step_train\",\"batch_size\",\"gamma\",\"greedy_exploration\",\"network\",\"optimizer\",\"lr\",\"memories\",\"max_size\",\"TD_gamma\"]\n", "df_DQN[df_DQN[\"sum\"] >= 500].groupby(by=columns, observed=True).count().sort_values(by=['sum'], ascending=False)" ] }, @@ -2625,22 +2617,29 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### DuelingNetwork" + "### DoubleDQN" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### SimpleNetwork" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ - "df_DQN = df[df[\"algo\"] == \"DQN\"].copy()\n", - "df_DQN = df_DQN[df_DQN[\"network\"] == \"SimpleDuelingNetwork\"]" + "df_DoubleDQN = df[df[\"algo\"] == \"DoubleDQN\"].copy()\n", + "df_DoubleDQN = df_DoubleDQN[df_DoubleDQN[\"network\"] == \"SimpleNetwork\"]" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -2675,3023 +2674,330 @@ " lr\n", " memories\n", " max_size\n", + " TD_gamma\n", " step\n", " sum\n", " \n", " \n", " \n", + " \n", + "\n", + "" + ], + "text/plain": [ + "Empty DataFrame\n", + "Columns: [algo, step_train, batch_size, gamma, greedy_exploration, network, , optimizer, lr, memories, max_size, TD_gamma, step, sum]\n", + "Index: []" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_DoubleDQN.sort_values(by =[\"sum\",\"step\"], ascending = [False, True]).head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(10,10)) \n", + "sns.heatmap(df_DQN.corr()[abs(df_DQN.corr()) > 0.05], annot = True, fmt='.2g',cmap= 'coolwarm', ax=ax)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
stepsum
31716DQN1.064.00.95AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.001ExperienceReplay51230.0500.0
27997DQN1.032.00.95EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay51240.0500.0
29082DQN1.032.00.99EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.001ExperienceReplay204840.0500.0
30601DQN1.032.01.00EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.001ExperienceReplay51240.0500.0
32461DQN1.064.00.95EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay51240.0500.0
33918DQN1.064.00.99EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay204840.0500.0
27626DQN1.032.00.95EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.001ExperienceReplay51250.0500.0
29827DQN1.032.01.00AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.001ExperienceReplay204850.0500.0
31346DQN1.064.00.95AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.001ExperienceReplay51250.0500.0
32803DQN1.064.00.99AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.001ExperienceReplay204850.0500.0
28340DQN1.032.00.99AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.001ExperienceReplay204860.0500.0
29859DQN1.032.01.00AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.001ExperienceReplay51260.0500.0
32804DQN1.064.00.99AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.001ExperienceReplay204860.0500.0
30201DQN1.032.01.00AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.001ExperienceReplay204870.0500.0
32805DQN1.064.00.99AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.001ExperienceReplay204870.0500.0
33921DQN1.064.00.99EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay204870.0500.0
35409DQN1.064.01.00EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.001ExperienceReplay204870.0500.0
28745DQN1.032.00.99AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.001ExperienceReplay51280.0500.0
31349DQN1.064.00.95AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.001ExperienceReplay51280.0500.0
28343DQN1.032.00.99AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.001ExperienceReplay204890.0500.0
\n", - "
" - ], - "text/plain": [ - " algo step_train batch_size gamma \\\n", - "31716 DQN 1.0 64.0 0.95 \n", - "27997 DQN 1.0 32.0 0.95 \n", - "29082 DQN 1.0 32.0 0.99 \n", - "30601 DQN 1.0 32.0 1.00 \n", - "32461 DQN 1.0 64.0 0.95 \n", - "33918 DQN 1.0 64.0 0.99 \n", - "27626 DQN 1.0 32.0 0.95 \n", - "29827 DQN 1.0 32.0 1.00 \n", - "31346 DQN 1.0 64.0 0.95 \n", - "32803 DQN 1.0 64.0 0.99 \n", - "28340 DQN 1.0 32.0 0.99 \n", - "29859 DQN 1.0 32.0 1.00 \n", - "32804 DQN 1.0 64.0 0.99 \n", - "30201 DQN 1.0 32.0 1.00 \n", - "32805 DQN 1.0 64.0 0.99 \n", - "33921 DQN 1.0 64.0 0.99 \n", - "35409 DQN 1.0 64.0 1.00 \n", - "28745 DQN 1.0 32.0 0.99 \n", - "31349 DQN 1.0 64.0 0.95 \n", - "28343 DQN 1.0 32.0 0.99 \n", - "\n", - " greedy_exploration network \\\n", - "31716 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork \n", - "27997 EpsilonGreedy-0.6 SimpleDuelingNetwork \n", - "29082 EpsilonGreedy-0.1 SimpleDuelingNetwork \n", - "30601 EpsilonGreedy-0.1 SimpleDuelingNetwork \n", - "32461 EpsilonGreedy-0.6 SimpleDuelingNetwork \n", - "33918 EpsilonGreedy-0.6 SimpleDuelingNetwork \n", - "27626 EpsilonGreedy-0.1 SimpleDuelingNetwork \n", - "29827 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork \n", - "31346 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork \n", - "32803 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork \n", - "28340 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork \n", - "29859 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork \n", - "32804 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork \n", - "30201 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork \n", - "32805 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork \n", - "33921 EpsilonGreedy-0.6 SimpleDuelingNetwork \n", - "35409 EpsilonGreedy-0.6 SimpleDuelingNetwork \n", - "28745 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork \n", - "31349 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork \n", - "28343 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork \n", - "\n", - " optimizer lr memories max_size step sum \n", - "31716 Adam 0.001 ExperienceReplay 512 30.0 500.0 \n", - "27997 Adam 0.001 ExperienceReplay 512 40.0 500.0 \n", - "29082 Adam 0.001 ExperienceReplay 2048 40.0 500.0 \n", - "30601 Adam 0.001 ExperienceReplay 512 40.0 500.0 \n", - "32461 Adam 0.001 ExperienceReplay 512 40.0 500.0 \n", - "33918 Adam 0.001 ExperienceReplay 2048 40.0 500.0 \n", - "27626 Adam 0.001 ExperienceReplay 512 50.0 500.0 \n", - "29827 Adam 0.001 ExperienceReplay 2048 50.0 500.0 \n", - "31346 Adam 0.001 ExperienceReplay 512 50.0 500.0 \n", - "32803 Adam 0.001 ExperienceReplay 2048 50.0 500.0 \n", - "28340 Adam 0.001 ExperienceReplay 2048 60.0 500.0 \n", - "29859 Adam 0.001 ExperienceReplay 512 60.0 500.0 \n", - "32804 Adam 0.001 ExperienceReplay 2048 60.0 500.0 \n", - "30201 Adam 0.001 ExperienceReplay 2048 70.0 500.0 \n", - "32805 Adam 0.001 ExperienceReplay 2048 70.0 500.0 \n", - "33921 Adam 0.001 ExperienceReplay 2048 70.0 500.0 \n", - "35409 Adam 0.001 ExperienceReplay 2048 70.0 500.0 \n", - "28745 Adam 0.001 ExperienceReplay 512 80.0 500.0 \n", - "31349 Adam 0.001 ExperienceReplay 512 80.0 500.0 \n", - "28343 Adam 0.001 ExperienceReplay 2048 90.0 500.0 " - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_DQN.sort_values(by =[\"sum\",\"step\"], ascending = [False, True]).head(20)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize=(10,10)) \n", - "sns.heatmap(df_DQN.corr()[abs(df_DQN.corr()) > 0.05], annot = True, fmt='.2g',cmap= 'coolwarm', ax=ax)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
stepsum
algostep_trainbatch_sizegammagreedy_explorationnetworkoptimizerlrmemoriesmax_size
DQN1.032.01.00AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay2048212121
64.01.00AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay2048202020
0.99AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay2048171717
EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0010ExperienceReplay2048151515
AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay2048141414
EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0010ExperienceReplay512141414
32.01.00EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0010ExperienceReplay2048141414
64.01.00EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0010ExperienceReplay2048131313
0.99AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay2048111111
32.01.00AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay2048111111
EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0010ExperienceReplay512111111
64.01.00EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0010ExperienceReplay512101010
0.95AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay2048888
EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay2048777
32.00.95EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay2048666
64.00.95EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0010ExperienceReplay512666
0.0001ExperienceReplay512555
EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.0010ExperienceReplay2048555
1.00EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.0010ExperienceReplay2048555
0.99EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay2048444
1.00AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay2048444
0.95AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay512444
AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay512444
32.00.95EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.0010ExperienceReplay2048444
0.99EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0010ExperienceReplay2048444
64.00.95AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay2048333
0.99EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay512333
32.00.95EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0010ExperienceReplay512333
EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.0010ExperienceReplay512333
1.00AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay512333
0.99EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay2048333
0.95AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay2048333
64.00.95AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay512222
32.00.95EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay512222
0.99EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay512222
64.00.95AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay512222
0.99AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay2048222
32.00.99AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay2048222
AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay512111
64.01.00EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay2048111
32.00.95AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay2048111
0.99AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay512111
1.00EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay2048111
0.99EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.0010ExperienceReplay2048111
64.00.99AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay512111
32.01.00EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.0010ExperienceReplay512111
64.00.95EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0010ExperienceReplay2048111
EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.0010ExperienceReplay512111
32.01.00AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay512111
64.00.95EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.0001ExperienceReplay512111
AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay2048111
32.00.95AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay512111
64.00.95AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay2048111
32.00.95AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay2048111
\n", - "
" - ], - "text/plain": [ - " \\\n", - "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size \n", - "DQN 1.0 32.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 21 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 20 \n", - " 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 17 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 15 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 14 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 14 \n", - " 32.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 14 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 13 \n", - " 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 11 \n", - " 32.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 11 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 11 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 10 \n", - " 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 8 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 7 \n", - " 32.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 6 \n", - " 64.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 6 \n", - " 0.0001 ExperienceReplay 512 5 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 5 \n", - " 1.00 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 5 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 4 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 4 \n", - " 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 32.0 0.95 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 3 \n", - " 32.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 3 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 3 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 3 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 3 \n", - " 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 32.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 2 \n", - " 32.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 2 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 0.99 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 64.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 32.0 1.00 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 64.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 32.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 64.0 0.95 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - "\n", - " step \\\n", - "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size \n", - "DQN 1.0 32.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 21 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 20 \n", - " 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 17 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 15 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 14 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 14 \n", - " 32.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 14 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 13 \n", - " 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 11 \n", - " 32.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 11 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 11 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 10 \n", - " 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 8 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 7 \n", - " 32.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 6 \n", - " 64.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 6 \n", - " 0.0001 ExperienceReplay 512 5 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 5 \n", - " 1.00 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 5 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 4 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 4 \n", - " 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 32.0 0.95 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 3 \n", - " 32.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 3 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 3 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 3 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 3 \n", - " 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 32.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 2 \n", - " 32.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 2 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 0.99 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 64.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 32.0 1.00 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 64.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 32.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 64.0 0.95 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - "\n", - " sum \n", - "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size \n", - "DQN 1.0 32.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 21 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 20 \n", - " 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 17 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 15 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 14 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 14 \n", - " 32.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 14 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 13 \n", - " 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 11 \n", - " 32.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 11 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 11 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 10 \n", - " 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 8 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 7 \n", - " 32.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 6 \n", - " 64.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 6 \n", - " 0.0001 ExperienceReplay 512 5 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 5 \n", - " 1.00 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 5 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 4 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 4 \n", - " 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 32.0 0.95 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 3 \n", - " 32.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 3 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 3 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 3 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 3 \n", - " 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 32.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 2 \n", - " 32.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 2 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 0.99 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 64.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 32.0 1.00 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 64.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 32.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 64.0 0.95 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 " - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "columns = [\"algo\",\"step_train\",\"batch_size\",\"gamma\",\"greedy_exploration\",\"network\",\"optimizer\",\"lr\",\"memories\",\"max_size\"]\n", - "df_DQN[df_DQN[\"sum\"] >= 500].groupby(by=columns, observed=True).count().sort_values(by=['sum'], ascending=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### DoubleDQN" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### SimpleNetwork" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "df_DoubleDQN = df[df[\"algo\"] == \"DoubleDQN\"].copy()\n", - "df_DoubleDQN = df_DoubleDQN[df_DoubleDQN[\"network\"] == \"SimpleNetwork\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
algostep_trainbatch_sizegammagreedy_explorationnetworkoptimizerlrmemoriesmax_sizestepsum
12930DoubleDQN1.032.01.00EpsilonGreedy-0.1SimpleNetworkAdam0.0010ExperienceReplay51230.0500.0
11412DoubleDQN1.032.00.99EpsilonGreedy-0.1SimpleNetworkAdam0.0010ExperienceReplay204840.0500.0
24122DoubleDQN32.064.00.99AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleNetworkAdam0.1000ExperienceReplay204840.0500.0
14796DoubleDQN1.064.00.95EpsilonGreedy-0.6SimpleNetworkAdam0.0010ExperienceReplay51290.0500.0
17742DoubleDQN1.064.01.00EpsilonGreedy-0.6SimpleNetworkAdam0.0010ExperienceReplay2048100.0500.0
14802DoubleDQN1.064.00.95EpsilonGreedy-0.6SimpleNetworkAdam0.0010ExperienceReplay512150.0500.0
15580DoubleDQN1.064.00.99AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleNetworkAdam0.1000ExperienceReplay2048180.0500.0
17719DoubleDQN1.064.01.00EpsilonGreedy-0.6SimpleNetworkAdam0.0001ExperienceReplay512180.0500.0
15922DoubleDQN1.064.00.99EpsilonGreedy-0.1SimpleNetworkAdam0.0010ExperienceReplay512190.0500.0
17720DoubleDQN1.064.01.00EpsilonGreedy-0.6SimpleNetworkAdam0.0001ExperienceReplay512190.0500.0
\n", - "
" - ], - "text/plain": [ - " algo step_train batch_size gamma \\\n", - "12930 DoubleDQN 1.0 32.0 1.00 \n", - "11412 DoubleDQN 1.0 32.0 0.99 \n", - "24122 DoubleDQN 32.0 64.0 0.99 \n", - "14796 DoubleDQN 1.0 64.0 0.95 \n", - "17742 DoubleDQN 1.0 64.0 1.00 \n", - "14802 DoubleDQN 1.0 64.0 0.95 \n", - "15580 DoubleDQN 1.0 64.0 0.99 \n", - "17719 DoubleDQN 1.0 64.0 1.00 \n", - "15922 DoubleDQN 1.0 64.0 0.99 \n", - "17720 DoubleDQN 1.0 64.0 1.00 \n", - "\n", - " greedy_exploration network optimizer \\\n", - "12930 EpsilonGreedy-0.1 SimpleNetwork Adam \n", - "11412 EpsilonGreedy-0.1 SimpleNetwork Adam \n", - "24122 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam \n", - "14796 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "17742 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "14802 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "15580 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam \n", - "17719 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "15922 EpsilonGreedy-0.1 SimpleNetwork Adam \n", - "17720 EpsilonGreedy-0.6 SimpleNetwork Adam \n", - "\n", - " lr memories max_size step sum \n", - "12930 0.0010 ExperienceReplay 512 30.0 500.0 \n", - "11412 0.0010 ExperienceReplay 2048 40.0 500.0 \n", - "24122 0.1000 ExperienceReplay 2048 40.0 500.0 \n", - "14796 0.0010 ExperienceReplay 512 90.0 500.0 \n", - "17742 0.0010 ExperienceReplay 2048 100.0 500.0 \n", - "14802 0.0010 ExperienceReplay 512 150.0 500.0 \n", - "15580 0.1000 ExperienceReplay 2048 180.0 500.0 \n", - "17719 0.0001 ExperienceReplay 512 180.0 500.0 \n", - "15922 0.0010 ExperienceReplay 512 190.0 500.0 \n", - "17720 0.0001 ExperienceReplay 512 190.0 500.0 " - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_DoubleDQN.sort_values(by =[\"sum\",\"step\"], ascending = [False, True]).head(10)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize=(10,10)) \n", - "sns.heatmap(df_DQN.corr()[abs(df_DQN.corr()) > 0.05], annot = True, fmt='.2g',cmap= 'coolwarm', ax=ax)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
stepsum
algostep_trainbatch_sizegammagreedy_explorationnetworkoptimizerlrmemoriesmax_size
DoubleDQN1.064.00.99EpsilonGreedy-0.1SimpleNetworkAdam0.0010ExperienceReplay512444
32.01.00AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleNetworkAdam0.0010ExperienceReplay512444
64.01.00EpsilonGreedy-0.6SimpleNetworkAdam0.0010ExperienceReplay2048333
0.0001ExperienceReplay512222
AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleNetworkAdam0.1000ExperienceReplay2048222
0.95AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleNetworkAdam0.0010ExperienceReplay512222
EpsilonGreedy-0.6SimpleNetworkAdam0.0001ExperienceReplay2048222
0.0010ExperienceReplay512222
1.00AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleNetworkAdam0.0001ExperienceReplay2048111
AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleNetworkAdam0.0010ExperienceReplay512111
AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleNetworkAdam0.1000ExperienceReplay512111
0.0010ExperienceReplay2048111
32.00.95AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleNetworkAdam0.0001ExperienceReplay512111
64.00.99AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleNetworkAdam0.1000ExperienceReplay2048111
32.00.95EpsilonGreedy-0.6SimpleNetworkAdam0.0010ExperienceReplay2048111
1.00AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleNetworkAdam0.1000ExperienceReplay512111
EpsilonGreedy-0.1SimpleNetworkAdam0.0010ExperienceReplay512111
EpsilonGreedy-0.6SimpleNetworkAdam0.0001ExperienceReplay2048111
0.99EpsilonGreedy-0.1SimpleNetworkAdam0.0010ExperienceReplay2048111
32.064.00.99AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleNetworkAdam0.1000ExperienceReplay2048111
\n", - "
" - ], - "text/plain": [ - " \\\n", - "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size \n", - "DoubleDQN 1.0 64.0 0.99 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 32.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " 0.0001 ExperienceReplay 512 2 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 2048 2 \n", - " 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " EpsilonGreedy-0.6 SimpleNetwork Adam 0.0001 ExperienceReplay 2048 2 \n", - " 0.0010 ExperienceReplay 512 2 \n", - " 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 512 1 \n", - " 0.0010 ExperienceReplay 2048 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 64.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 2048 1 \n", - " 32.0 0.95 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.6 SimpleNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 0.99 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 32.0 64.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 2048 1 \n", - "\n", - " step \\\n", - "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size \n", - "DoubleDQN 1.0 64.0 0.99 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 32.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " 0.0001 ExperienceReplay 512 2 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 2048 2 \n", - " 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " EpsilonGreedy-0.6 SimpleNetwork Adam 0.0001 ExperienceReplay 2048 2 \n", - " 0.0010 ExperienceReplay 512 2 \n", - " 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 512 1 \n", - " 0.0010 ExperienceReplay 2048 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 64.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 2048 1 \n", - " 32.0 0.95 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.6 SimpleNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 0.99 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 32.0 64.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 2048 1 \n", - "\n", - " sum \n", - "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size \n", - "DoubleDQN 1.0 64.0 0.99 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 32.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 4 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 3 \n", - " 0.0001 ExperienceReplay 512 2 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 2048 2 \n", - " 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " EpsilonGreedy-0.6 SimpleNetwork Adam 0.0001 ExperienceReplay 2048 2 \n", - " 0.0010 ExperienceReplay 512 2 \n", - " 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 512 1 \n", - " 0.0010 ExperienceReplay 2048 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 64.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 2048 1 \n", - " 32.0 0.95 EpsilonGreedy-0.6 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.6 SimpleNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 0.99 EpsilonGreedy-0.1 SimpleNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 32.0 64.0 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleNetwork Adam 0.1000 ExperienceReplay 2048 1 " - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "columns = [\"algo\",\"step_train\",\"batch_size\",\"gamma\",\"greedy_exploration\",\"network\",\"optimizer\",\"lr\",\"memories\",\"max_size\"]\n", - "df_DoubleDQN[df_DoubleDQN[\"sum\"] >= 500].groupby(by=columns, observed=True).count().sort_values(by=['sum'], ascending=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### DuelingNetwork" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ - "df_DoubleDQN = df[df[\"algo\"] == \"DoubleDQN\"].copy()\n", - "df_DoubleDQN = df_DoubleDQN[df_DoubleDQN[\"network\"] == \"SimpleDuelingNetwork\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
algostep_trainbatch_sizegammagreedy_explorationnetworkoptimizerlrmemoriesmax_sizestepsum
12340DoubleDQN1.032.01.00AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay204820.0500.0
17645DoubleDQN1.064.01.00EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.1000ExperienceReplay51260.0500.0
13775DoubleDQN1.064.00.95AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay2048110.0500.0
9747DoubleDQN1.032.00.95EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.0010ExperienceReplay2048130.0500.0
12320DoubleDQN1.032.01.00AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay512130.0500.0
13777DoubleDQN1.064.00.95AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay2048130.0500.0
12321DoubleDQN1.032.01.00AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay512140.0500.0
14522DoubleDQN1.064.00.95EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay2048140.0500.0
16785DoubleDQN1.064.01.00AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay512140.0500.0
10803DoubleDQN1.032.00.99AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay2048150.0500.0
\n", - "
" - ], - "text/plain": [ - " algo step_train batch_size gamma \\\n", - "12340 DoubleDQN 1.0 32.0 1.00 \n", - "17645 DoubleDQN 1.0 64.0 1.00 \n", - "13775 DoubleDQN 1.0 64.0 0.95 \n", - "9747 DoubleDQN 1.0 32.0 0.95 \n", - "12320 DoubleDQN 1.0 32.0 1.00 \n", - "13777 DoubleDQN 1.0 64.0 0.95 \n", - "12321 DoubleDQN 1.0 32.0 1.00 \n", - "14522 DoubleDQN 1.0 64.0 0.95 \n", - "16785 DoubleDQN 1.0 64.0 1.00 \n", - "10803 DoubleDQN 1.0 32.0 0.99 \n", - "\n", - " greedy_exploration network \\\n", - "12340 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork \n", - "17645 EpsilonGreedy-0.6 SimpleDuelingNetwork \n", - "13775 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork \n", - "9747 EpsilonGreedy-0.1 SimpleDuelingNetwork \n", - "12320 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork \n", - "13777 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork \n", - "12321 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork \n", - "14522 EpsilonGreedy-0.6 SimpleDuelingNetwork \n", - "16785 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork \n", - "10803 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork \n", - "\n", - " optimizer lr memories max_size step sum \n", - "12340 Adam 0.0010 ExperienceReplay 2048 20.0 500.0 \n", - "17645 Adam 0.1000 ExperienceReplay 512 60.0 500.0 \n", - "13775 Adam 0.0001 ExperienceReplay 2048 110.0 500.0 \n", - "9747 Adam 0.0010 ExperienceReplay 2048 130.0 500.0 \n", - "12320 Adam 0.0001 ExperienceReplay 512 130.0 500.0 \n", - "13777 Adam 0.0001 ExperienceReplay 2048 130.0 500.0 \n", - "12321 Adam 0.0001 ExperienceReplay 512 140.0 500.0 \n", - "14522 Adam 0.0001 ExperienceReplay 2048 140.0 500.0 \n", - "16785 Adam 0.0001 ExperienceReplay 512 140.0 500.0 \n", - "10803 Adam 0.0001 ExperienceReplay 2048 150.0 500.0 " - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_DoubleDQN.sort_values(by =[\"sum\",\"step\"], ascending = [False, True]).head(10)" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize=(10,10)) \n", - "sns.heatmap(df_DoubleDQN.corr()[abs(df_DoubleDQN.corr()) > 0.05], annot = True, fmt='.2g',cmap= 'coolwarm', ax=ax)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + "
stepsum
algostep_trainbatch_sizegammagreedy_explorationnetworkoptimizerlrmemoriesmax_size
DoubleDQN1.064.00.99AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay512666
32.00.99EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay2048666
0.95EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay2048555
64.01.00AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay2048444
0.99EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay512444
0.95AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay2048444
AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay2048444
EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay2048333
EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.0001ExperienceReplay2048333
32.00.95AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay512222
1.00AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay512222
64.01.00AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay512222
0.99AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay2048222
32.00.95AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay2048222
1.00AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay512222
64.01.00EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.1000ExperienceReplay512222
32.00.99AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay512222
2048222
64.00.95EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0010ExperienceReplay512111
1.00EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay512111
EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.0001ExperienceReplay512111
32.00.95AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay2048111
64.01.00AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay512111
32.00.95AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay512111
64.01.00AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay512111
0.99EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay2048111
32.00.95EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.0010ExperienceReplay2048111
EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0010ExperienceReplay512111
0.99AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay512111
1.00AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay2048111
0.0001ExperienceReplay2048111
64.00.95EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay512111
EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.0010ExperienceReplay2048111
0.0001ExperienceReplay512111
32.00.99AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay2048111
EpsilonGreedy-0.1SimpleDuelingNetworkAdam0.0010ExperienceReplay2048111
64.00.95AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay512111
32.01.00AdaptativeEpsilonGreedy-0.3-0.1-30000-0SimpleDuelingNetworkAdam0.0001ExperienceReplay512111
EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay512111algostep_trainbatch_sizegammagreedy_explorationnetworkoptimizerlrmemoriesmax_sizeTD_gamma
AdaptativeEpsilonGreedy-0.8-0.2-10000-0SimpleDuelingNetworkAdam0.0010ExperienceReplay2048111
\n", + "
" + ], + "text/plain": [ + "Empty DataFrame\n", + "Columns: [, step, sum]\n", + "Index: []" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "columns = [\"algo\",\"step_train\",\"batch_size\",\"gamma\",\"greedy_exploration\",\"network\",\"optimizer\",\"lr\",\"memories\",\"max_size\",\"TD_gamma\"]\n", + "df_DoubleDQN[df_DoubleDQN[\"sum\"] >= 500].groupby(by=columns, observed=True).count().sort_values(by=['sum'], ascending=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### DuelingNetwork" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "df_DoubleDQN = df[df[\"algo\"] == \"DoubleDQN\"].copy()\n", + "df_DoubleDQN = df_DoubleDQN[df_DoubleDQN[\"network\"] == \"SimpleDuelingNetwork\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + "
algostep_trainbatch_sizegammagreedy_explorationnetworkoptimizerlrmemoriesmax_sizeTD_gammastepsum
512111
\n", + "
" + ], + "text/plain": [ + "Empty DataFrame\n", + "Columns: [algo, step_train, batch_size, gamma, greedy_exploration, network, , optimizer, lr, memories, max_size, TD_gamma, step, sum]\n", + "Index: []" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_DoubleDQN.sort_values(by =[\"sum\",\"step\"], ascending = [False, True]).head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "D:\\Users\\nathan\\Anaconda3\\envs\\cpmt\\lib\\site-packages\\seaborn\\matrix.py:204: RuntimeWarning: All-NaN slice encountered\n", + " vmin = np.nanmin(calc_data)\n", + "D:\\Users\\nathan\\Anaconda3\\envs\\cpmt\\lib\\site-packages\\seaborn\\matrix.py:209: RuntimeWarning: All-NaN slice encountered\n", + " vmax = np.nanmax(calc_data)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(10,10)) \n", + "sns.heatmap(df_DoubleDQN.corr()[abs(df_DoubleDQN.corr()) > 0.05], annot = True, fmt='.2g',cmap= 'coolwarm', ax=ax)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", " \n", "
stepsum
EpsilonGreedy-0.6SimpleDuelingNetworkAdam0.0001ExperienceReplay2048111algostep_trainbatch_sizegammagreedy_explorationnetworkoptimizerlrmemoriesmax_sizeTD_gamma
\n", "
" ], "text/plain": [ - " \\\n", - "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size \n", - "DoubleDQN 1.0 64.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 6 \n", - " 32.0 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 6 \n", - " 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 5 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 4 \n", - " 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 4 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 3 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 3 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 2 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 2 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.1000 ExperienceReplay 512 2 \n", - " 32.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 2048 2 \n", - " 64.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 32.0 0.95 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 0.0001 ExperienceReplay 2048 1 \n", - " 64.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 0.0001 ExperienceReplay 512 1 \n", - " 32.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 32.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 512 1 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - "\n", - " step \\\n", - "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size \n", - "DoubleDQN 1.0 64.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 6 \n", - " 32.0 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 6 \n", - " 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 5 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 4 \n", - " 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 4 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 3 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 3 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 2 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 2 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.1000 ExperienceReplay 512 2 \n", - " 32.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 2048 2 \n", - " 64.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 32.0 0.95 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 0.0001 ExperienceReplay 2048 1 \n", - " 64.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 0.0001 ExperienceReplay 512 1 \n", - " 32.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 32.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 512 1 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - "\n", - " sum \n", - "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size \n", - "DoubleDQN 1.0 64.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 6 \n", - " 32.0 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 6 \n", - " 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 5 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 4 \n", - " 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 4 \n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 4 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 3 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 3 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 2 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 2 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 2 \n", - " 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 64.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.1000 ExperienceReplay 512 2 \n", - " 32.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 2 \n", - " 2048 2 \n", - " 64.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 32.0 0.95 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 64.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 0.99 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 \n", - " 32.0 0.95 EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 0.99 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 1 \n", - " 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 0.0001 ExperienceReplay 2048 1 \n", - " 64.0 0.95 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 0.0001 ExperienceReplay 512 1 \n", - " 32.0 0.99 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " EpsilonGreedy-0.1 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 64.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " 32.0 1.00 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 512 1 \n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 2048 1 \n", - " 512 1 \n", - " EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0001 ExperienceReplay 2048 1 " + "Empty DataFrame\n", + "Columns: [, step, sum]\n", + "Index: []" ] }, "execution_count": 32, @@ -5700,7 +3006,7 @@ } ], "source": [ - "columns = [\"algo\",\"step_train\",\"batch_size\",\"gamma\",\"greedy_exploration\",\"network\",\"optimizer\",\"lr\",\"memories\",\"max_size\"]\n", + "columns = [\"algo\",\"step_train\",\"batch_size\",\"gamma\",\"greedy_exploration\",\"network\",\"optimizer\",\"lr\",\"memories\",\"max_size\",\"TD_gamma\"]\n", "df_DoubleDQN[df_DoubleDQN[\"sum\"] >= 500].groupby(by=columns, observed=True).count().sort_values(by=['sum'], ascending=False)" ] }, @@ -5757,401 +3063,20 @@ " lr\n", " memories\n", " max_size\n", + " TD_gamma\n", " step\n", " sum\n", " \n", " \n", " \n", - " \n", - " 2672\n", - " CategoricalDQN\n", - " 1.0\n", - " 64.0\n", - " 0.95\n", - " EpsilonGreedy-0.1\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " 60.0\n", - " 500.0\n", - " \n", - " \n", - " 8419\n", - " CategoricalDQN\n", - " 32.0\n", - " 64.0\n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0001\n", - " ExperienceReplay\n", - " 512\n", - " 180.0\n", - " 500.0\n", - " \n", - " \n", - " 3979\n", - " CategoricalDQN\n", - " 1.0\n", - " 64.0\n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " 110.0\n", - " 403.0\n", - " \n", - " \n", - " 5525\n", - " CategoricalDQN\n", - " 32.0\n", - " 32.0\n", - " 0.99\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.1000\n", - " ExperienceReplay\n", - " 2048\n", - " 70.0\n", - " 388.0\n", - " \n", - " \n", - " 463\n", - " CategoricalDQN\n", - " 1.0\n", - " 32.0\n", - " 0.95\n", - " EpsilonGreedy-0.1\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " 290.0\n", - " 355.0\n", - " \n", - " \n", - " 2163\n", - " CategoricalDQN\n", - " 1.0\n", - " 32.0\n", - " 1.00\n", - " EpsilonGreedy-0.6\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 512\n", - " 240.0\n", - " 328.0\n", - " \n", - " \n", - " 2659\n", - " CategoricalDQN\n", - " 1.0\n", - " 64.0\n", - " 0.95\n", - " EpsilonGreedy-0.1\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0001\n", - " ExperienceReplay\n", - " 512\n", - " 240.0\n", - " 327.0\n", - " \n", - " \n", - " 2488\n", - " CategoricalDQN\n", - " 1.0\n", - " 64.0\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " 80.0\n", - " 326.0\n", - " \n", - " \n", - " 1975\n", - " CategoricalDQN\n", - " 1.0\n", - " 32.0\n", - " 1.00\n", - " EpsilonGreedy-0.1\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 512\n", - " 220.0\n", - " 316.0\n", - " \n", - " \n", - " 2493\n", - " CategoricalDQN\n", - " 1.0\n", - " 64.0\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " 130.0\n", - " 312.0\n", - " \n", - " \n", - " 4366\n", - " CategoricalDQN\n", - " 1.0\n", - " 64.0\n", - " 1.00\n", - " EpsilonGreedy-0.6\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " 260.0\n", - " 305.0\n", - " \n", - " \n", - " 461\n", - " CategoricalDQN\n", - " 1.0\n", - " 32.0\n", - " 0.95\n", - " EpsilonGreedy-0.1\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " 270.0\n", - " 294.0\n", - " \n", - " \n", - " 3974\n", - " CategoricalDQN\n", - " 1.0\n", - " 64.0\n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " 60.0\n", - " 292.0\n", - " \n", - " \n", - " 8906\n", - " CategoricalDQN\n", - " 32.0\n", - " 64.0\n", - " 1.00\n", - " EpsilonGreedy-0.6\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.1000\n", - " ExperienceReplay\n", - " 512\n", - " 90.0\n", - " 292.0\n", - " \n", - " \n", - " 2158\n", - " CategoricalDQN\n", - " 1.0\n", - " 32.0\n", - " 1.00\n", - " EpsilonGreedy-0.6\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 512\n", - " 190.0\n", - " 290.0\n", - " \n", - " \n", - " 2159\n", - " CategoricalDQN\n", - " 1.0\n", - " 32.0\n", - " 1.00\n", - " EpsilonGreedy-0.6\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 512\n", - " 200.0\n", - " 282.0\n", - " \n", - " \n", - " 4023\n", - " CategoricalDQN\n", - " 1.0\n", - " 64.0\n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 512\n", - " 240.0\n", - " 278.0\n", - " \n", - " \n", - " 2133\n", - " CategoricalDQN\n", - " 1.0\n", - " 32.0\n", - " 1.00\n", - " EpsilonGreedy-0.6\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " 250.0\n", - " 276.0\n", - " \n", - " \n", - " 2726\n", - " CategoricalDQN\n", - " 1.0\n", - " 64.0\n", - " 0.95\n", - " EpsilonGreedy-0.1\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 512\n", - " 290.0\n", - " 266.0\n", - " \n", - " \n", - " 2156\n", - " CategoricalDQN\n", - " 1.0\n", - " 32.0\n", - " 1.00\n", - " EpsilonGreedy-0.6\n", - " C51Network\n", - " \n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 512\n", - " 170.0\n", - " 261.0\n", - " \n", " \n", "\n", "" ], "text/plain": [ - " algo step_train batch_size gamma \\\n", - "2672 CategoricalDQN 1.0 64.0 0.95 \n", - "8419 CategoricalDQN 32.0 64.0 1.00 \n", - "3979 CategoricalDQN 1.0 64.0 1.00 \n", - "5525 CategoricalDQN 32.0 32.0 0.99 \n", - "463 CategoricalDQN 1.0 32.0 0.95 \n", - "2163 CategoricalDQN 1.0 32.0 1.00 \n", - "2659 CategoricalDQN 1.0 64.0 0.95 \n", - "2488 CategoricalDQN 1.0 64.0 0.95 \n", - "1975 CategoricalDQN 1.0 32.0 1.00 \n", - "2493 CategoricalDQN 1.0 64.0 0.95 \n", - "4366 CategoricalDQN 1.0 64.0 1.00 \n", - "461 CategoricalDQN 1.0 32.0 0.95 \n", - "3974 CategoricalDQN 1.0 64.0 1.00 \n", - "8906 CategoricalDQN 32.0 64.0 1.00 \n", - "2158 CategoricalDQN 1.0 32.0 1.00 \n", - "2159 CategoricalDQN 1.0 32.0 1.00 \n", - "4023 CategoricalDQN 1.0 64.0 1.00 \n", - "2133 CategoricalDQN 1.0 32.0 1.00 \n", - "2726 CategoricalDQN 1.0 64.0 0.95 \n", - "2156 CategoricalDQN 1.0 32.0 1.00 \n", - "\n", - " greedy_exploration network optimizer lr \\\n", - "2672 EpsilonGreedy-0.1 C51Network Adam 0.0010 \n", - "8419 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 C51Network Adam 0.0001 \n", - "3979 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 C51Network Adam 0.0010 \n", - "5525 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 C51Network Adam 0.1000 \n", - "463 EpsilonGreedy-0.1 C51Network Adam 0.0010 \n", - "2163 EpsilonGreedy-0.6 C51Network Adam 0.0010 \n", - "2659 EpsilonGreedy-0.1 C51Network Adam 0.0001 \n", - "2488 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 C51Network Adam 0.0010 \n", - "1975 EpsilonGreedy-0.1 C51Network Adam 0.0010 \n", - "2493 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 C51Network Adam 0.0010 \n", - "4366 EpsilonGreedy-0.6 C51Network Adam 0.0010 \n", - "461 EpsilonGreedy-0.1 C51Network Adam 0.0010 \n", - "3974 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 C51Network Adam 0.0010 \n", - "8906 EpsilonGreedy-0.6 C51Network Adam 0.1000 \n", - "2158 EpsilonGreedy-0.6 C51Network Adam 0.0010 \n", - "2159 EpsilonGreedy-0.6 C51Network Adam 0.0010 \n", - "4023 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 C51Network Adam 0.0010 \n", - "2133 EpsilonGreedy-0.6 C51Network Adam 0.0010 \n", - "2726 EpsilonGreedy-0.1 C51Network Adam 0.0010 \n", - "2156 EpsilonGreedy-0.6 C51Network Adam 0.0010 \n", - "\n", - " memories max_size step sum \n", - "2672 ExperienceReplay 2048 60.0 500.0 \n", - "8419 ExperienceReplay 512 180.0 500.0 \n", - "3979 ExperienceReplay 2048 110.0 403.0 \n", - "5525 ExperienceReplay 2048 70.0 388.0 \n", - "463 ExperienceReplay 2048 290.0 355.0 \n", - "2163 ExperienceReplay 512 240.0 328.0 \n", - "2659 ExperienceReplay 512 240.0 327.0 \n", - "2488 ExperienceReplay 2048 80.0 326.0 \n", - "1975 ExperienceReplay 512 220.0 316.0 \n", - "2493 ExperienceReplay 2048 130.0 312.0 \n", - "4366 ExperienceReplay 2048 260.0 305.0 \n", - "461 ExperienceReplay 2048 270.0 294.0 \n", - "3974 ExperienceReplay 2048 60.0 292.0 \n", - "8906 ExperienceReplay 512 90.0 292.0 \n", - "2158 ExperienceReplay 512 190.0 290.0 \n", - "2159 ExperienceReplay 512 200.0 282.0 \n", - "4023 ExperienceReplay 512 240.0 278.0 \n", - "2133 ExperienceReplay 2048 250.0 276.0 \n", - "2726 ExperienceReplay 512 290.0 266.0 \n", - "2156 ExperienceReplay 512 170.0 261.0 " + "Empty DataFrame\n", + "Columns: [algo, step_train, batch_size, gamma, greedy_exploration, network, , optimizer, lr, memories, max_size, TD_gamma, step, sum]\n", + "Index: []" ] }, "execution_count": 34, @@ -6168,6 +3093,16 @@ "execution_count": 35, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "D:\\Users\\nathan\\Anaconda3\\envs\\cpmt\\lib\\site-packages\\seaborn\\matrix.py:204: RuntimeWarning: All-NaN slice encountered\n", + " vmin = np.nanmin(calc_data)\n", + "D:\\Users\\nathan\\Anaconda3\\envs\\cpmt\\lib\\site-packages\\seaborn\\matrix.py:209: RuntimeWarning: All-NaN slice encountered\n", + " vmax = np.nanmax(calc_data)\n" + ] + }, { "data": { "text/plain": [ @@ -6180,7 +3115,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -6232,6 +3167,7 @@ " \n", " \n", " \n", + " \n", " step\n", " sum\n", " \n", @@ -6246,178 +3182,21 @@ " lr\n", " memories\n", " max_size\n", + " TD_gamma\n", " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " CategoricalDQN\n", - " 1.0\n", - " 64.0\n", - " 0.95\n", - " EpsilonGreedy-0.1\n", - " C51Network\n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " 1.0\n", - " 1.0\n", - " 1.0\n", - " \n", - " \n", - " 32.0\n", - " 64.0\n", - " 1.00\n", - " AdaptativeEpsilonGreedy-0.8-0.2-10000-0\n", - " C51Network\n", - " Adam\n", - " 0.0001\n", - " ExperienceReplay\n", - " 512\n", - " 1.0\n", - " 1.0\n", - " 1.0\n", - " \n", - " \n", - " 1.0\n", - " 64.0\n", - " 0.95\n", - " AdaptativeEpsilonGreedy-0.3-0.1-30000-0\n", - " C51Network\n", - " Adam\n", - " 0.0001\n", - " ExperienceReplay\n", - " 2048\n", - " NaN\n", - " NaN\n", - " NaN\n", - " \n", - " \n", - " 512\n", - " NaN\n", - " NaN\n", - " NaN\n", - " \n", - " \n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " NaN\n", - " NaN\n", - " NaN\n", - " \n", - " \n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " ...\n", - " \n", - " \n", - " DoubleDQN\n", - " 32.0\n", - " 64.0\n", - " 1.00\n", - " EpsilonGreedy-0.6\n", - " SimpleDuelingNetwork\n", - " Adam\n", - " 0.0010\n", - " ExperienceReplay\n", - " 512\n", - " NaN\n", - " NaN\n", - " NaN\n", - " \n", - " \n", - " SimpleNetwork\n", - " Adam\n", - " 0.0001\n", - " ExperienceReplay\n", - " 2048\n", - " NaN\n", - " NaN\n", - " NaN\n", - " \n", - " \n", - " 512\n", - " NaN\n", - " NaN\n", - " NaN\n", - " \n", - " \n", - " 0.0010\n", - " ExperienceReplay\n", - " 2048\n", - " NaN\n", - " NaN\n", - " NaN\n", - " \n", - " \n", - " 512\n", - " NaN\n", - " NaN\n", - " NaN\n", - " \n", " \n", "\n", - "

576 rows × 3 columns

\n", "" ], "text/plain": [ - " \\\n", - "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size \n", - "CategoricalDQN 1.0 64.0 0.95 EpsilonGreedy-0.1 C51Network Adam 0.0010 ExperienceReplay 2048 1.0 \n", - " 32.0 64.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 C51Network Adam 0.0001 ExperienceReplay 512 1.0 \n", - " 1.0 64.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 C51Network Adam 0.0001 ExperienceReplay 2048 NaN \n", - " 512 NaN \n", - " 0.0010 ExperienceReplay 2048 NaN \n", - "... ... \n", - "DoubleDQN 32.0 64.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 NaN \n", - " SimpleNetwork Adam 0.0001 ExperienceReplay 2048 NaN \n", - " 512 NaN \n", - " 0.0010 ExperienceReplay 2048 NaN \n", - " 512 NaN \n", - "\n", - " step \\\n", - "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size \n", - "CategoricalDQN 1.0 64.0 0.95 EpsilonGreedy-0.1 C51Network Adam 0.0010 ExperienceReplay 2048 1.0 \n", - " 32.0 64.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 C51Network Adam 0.0001 ExperienceReplay 512 1.0 \n", - " 1.0 64.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 C51Network Adam 0.0001 ExperienceReplay 2048 NaN \n", - " 512 NaN \n", - " 0.0010 ExperienceReplay 2048 NaN \n", - "... ... \n", - "DoubleDQN 32.0 64.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 NaN \n", - " SimpleNetwork Adam 0.0001 ExperienceReplay 2048 NaN \n", - " 512 NaN \n", - " 0.0010 ExperienceReplay 2048 NaN \n", - " 512 NaN \n", - "\n", - " sum \n", - "algo step_train batch_size gamma greedy_exploration network optimizer lr memories max_size \n", - "CategoricalDQN 1.0 64.0 0.95 EpsilonGreedy-0.1 C51Network Adam 0.0010 ExperienceReplay 2048 1.0 \n", - " 32.0 64.0 1.00 AdaptativeEpsilonGreedy-0.8-0.2-10000-0 C51Network Adam 0.0001 ExperienceReplay 512 1.0 \n", - " 1.0 64.0 0.95 AdaptativeEpsilonGreedy-0.3-0.1-30000-0 C51Network Adam 0.0001 ExperienceReplay 2048 NaN \n", - " 512 NaN \n", - " 0.0010 ExperienceReplay 2048 NaN \n", - "... ... \n", - "DoubleDQN 32.0 64.0 1.00 EpsilonGreedy-0.6 SimpleDuelingNetwork Adam 0.0010 ExperienceReplay 512 NaN \n", - " SimpleNetwork Adam 0.0001 ExperienceReplay 2048 NaN \n", - " 512 NaN \n", - " 0.0010 ExperienceReplay 2048 NaN \n", - " 512 NaN \n", - "\n", - "[576 rows x 3 columns]" + "Empty DataFrame\n", + "Columns: [, step, sum]\n", + "Index: []" ] }, "execution_count": 36, @@ -6426,7 +3205,7 @@ } ], "source": [ - "columns = [\"algo\",\"step_train\",\"batch_size\",\"gamma\",\"greedy_exploration\",\"network\",\"optimizer\",\"lr\",\"memories\",\"max_size\"]\n", + "columns = [\"algo\",\"step_train\",\"batch_size\",\"gamma\",\"greedy_exploration\",\"network\",\"optimizer\",\"lr\",\"memories\",\"max_size\",\"TD_gamma\"]\n", "df_CategoricalDQN[df_CategoricalDQN[\"sum\"] >= 500].groupby(by=columns).count().sort_values(by=['sum'], ascending=False)" ] }, @@ -6454,7 +3233,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.7.8" } }, "nbformat": 4, diff --git a/results/result.py b/results/result.py index 2887969..20b32fc 100644 --- a/results/result.py +++ b/results/result.py @@ -37,7 +37,8 @@ "optimizer": {"class": optimizer, "param": {"lr": lr}}, "memory": {"class": memory, - "param": {"max_size": [512, 2048]}}, + "param": {"max_size": [512, 2048], + "gamma": [0, 0.5, 1]}}, "dueling": True }, {"agent": {"class": [CategoricalDQN], diff --git a/setup.py b/setup.py index ba43734..3f8593c 100644 --- a/setup.py +++ b/setup.py @@ -30,7 +30,7 @@ setuptools.setup( author="french ai team", name='blobrl', - version='0.1.0', + version='0.1.1', license="Apache-2.0", description='Reinforcement learning with pytorch ', long_description=README, diff --git a/tests/memories/test_experience_replay.py b/tests/memories/test_experience_replay.py index f148a66..426f01c 100644 --- a/tests/memories/test_experience_replay.py +++ b/tests/memories/test_experience_replay.py @@ -1,7 +1,19 @@ import torch - +import pytest from blobrl.memories import ExperienceReplay +list_fail = [-1, -1.0, -100, -58.654, 1.1, 10, 23.154] +list_work = [0, 1, 0.0, 1.0, 0.5, 0.236515, 0.98] + + +def test_init_(): + for gamma in list_fail: + with pytest.raises(ValueError): + ExperienceReplay(max_size=100, gamma=gamma) + + for gamma in list_work: + ExperienceReplay(max_size=100, gamma=gamma) + def test_experience_replay(): max_size = 2 @@ -29,3 +41,24 @@ def test_experience_replay(): mem.extend(obs_s, actions, rewards, next_obs_s, dones) mem.sample(2, device=torch.device("cpu")) + + +def test_get_sample(): + max_size = 10 + + for gamma in list_work: + mem = ExperienceReplay(max_size, gamma=gamma) + for i in range(10): + mem.buffer.append([i, i, i, i, False]) + + for i in range(10): + assert mem.get_sample(i)[0] == i + + mem.buffer.append([10, 10, 10, 10, True]) + assert mem.get_sample(0)[0] == 1 + + +def test_str_(): + mem = ExperienceReplay(max_size=1000, gamma=0.5) + + assert mem.__str__() == 'ExperienceReplay-1000-0.5'