Add overall setting and ddpg baseline (#1)

* Add overall CI settings

* Add specific build dir to travis

* Add before install/script condition to travis

* Add ddpg baseline

* Add wandb, remove algorithms except ddpg

* Remove init file in script

* Separate config file for ddpg

* Remove unnecessary examples

* Remove unnecessary args opt

* Add pre-commit setting

* Change pre-commit settings

* Change travis-ci setting

* Fix travis-ci issue

* Modify argparse arguments, fix requirements

* Change arguments order

scripts/algorithms/common/buffer/replay_buffer.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+"""Replay buffer for baselines."""
+
+import random
+from collections import deque
+
+import numpy as np
+import torch
+
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+
+class ReplayBuffer:
+    """Fixed-size buffer to store experience tuples.
+
+    Taken from Udacity deep-reinforcement-learning github repository:
+    https://github.com/udacity/deep-reinforcement-learning/blob/master/
+    ddpg-pendulum/ddpg_agent.py
+
+    Attributes:
+        buffer (deque): deque of replay buffer
+        batch_size (int): size of a batched sampled from replay buffer for training
+
+    """
+
+    def __init__(self, buffer_size, batch_size, seed, demo=None):
+        """Initialize a ReplayBuffer object.
+
+        Args:
+            buffer_size (int): size of replay buffer for experience
+            batch_size (int): size of a batched sampled from replay buffer for training
+            seed (int): random seed
+            demo (deque) : demonstration deque
+
+        """
+        self.buffer = deque(maxlen=buffer_size) if not demo else demo
+
+        self.batch_size = batch_size
+        random.seed(seed)
+
+    def add(self, state, action, reward, next_state, done):
+        """Add a new experience to memory."""
+        self.buffer.append((state, action, reward, next_state, done))
+
+    def extend(self, transitions):
+        """Add experiences to memory."""
+        self.buffer.extend(transitions)
+
+    def sample(self):
+        """Randomly sample a batch of experiences from memory."""
+        experiences = random.sample(self.buffer, k=self.batch_size)
+
+        states, actions, rewards, next_states, dones = [], [], [], [], []
+
+        for e in experiences:
+            states.append(np.expand_dims(e[0], axis=0))
+            actions.append(e[1])
+            rewards.append(e[2])
+            next_states.append(np.expand_dims(e[3], axis=0))
+            dones.append(e[4])
+
+        states = torch.from_numpy(np.vstack(states)).float().to(device)
+        actions = torch.from_numpy(np.vstack(actions)).float().to(device)
+        rewards = torch.from_numpy(np.vstack(rewards)).float().to(device)
+        next_states = torch.from_numpy(np.vstack(next_states)).float().to(device)
+        dones = torch.from_numpy(np.vstack(dones).astype(np.uint8)).float().to(device)
+
+        return (states, actions, rewards, next_states, dones)
+
+    def __len__(self):
+        """Return the current size of internal memory."""
+        return len(self.buffer)