Htydjtk

I'm trying to replicate the DQN Atari experiment. Actually my DQN isn't performing well; checking another one's codes, I saw something about experience replay which I don't understand. First, when you define your CNN, in the first layer you have to specify the size (I'm using Keras + Tensorflow so in my case it's something like (105, 80, 4), which corresponds to height, width and number of images I feed my CNN.). In the codes I revisited, when they get the minibatch from the memory, I see they usually fed the CNN without "packing" it on 4 batches. How it is possible? I mean for example if you get 32 random sampled experiences, don't you need to make batches of 4 before feeding it?
Here are an example of what I'm saying: https://github.com/yilundu/DQN-DDQN-on-Space-Invaders/blob/master/replay_buffer.py
https://github.com/yilundu/DQN-DDQN-on-Space-Invaders/blob/master/deep_Q.py
In this code, that's how he/she stores the experiences:

def add(self, s, a, r, d, s2):

        """Add an experience to the buffer"""

        # S represents current state, a is action,

        # r is reward, d is whether it is the end, 

        # and s2 is next state

        experience = (s, a, r, d, s2)

        if self.count < self.buffer_size:

            self.buffer.append(experience)

            self.count += 1

        else:

            self.buffer.popleft()

            self.buffer.append(experience)

Then when you need to use them:

 def sample(self, batch_size):

        """Samples a total of elements equal to batch_size from buffer

        if buffer contains enough elements. Otherwise return all elements"""



        batch = 



        if self.count < batch_size:

            batch = random.sample(self.buffer, self.count)

        else:

            batch = random.sample(self.buffer, batch_size)



        # Maps each experience in batch in batches of states, actions, rewards

        # and new states

        s_batch, a_batch, r_batch, d_batch, s2_batch = list(map(np.array, list(zip(*batch))))



        return s_batch, a_batch, r_batch, d_batch, s2_batch

Ok, so now you have a batch of 32 states, actions, rewards, done and next states.

This is how you feed the state batch (s_batch) and next state batch (s2_batch) to the CNN:

def train(self, s_batch, a_batch, r_batch, d_batch, s2_batch, observation_num):

        """Trains network to fit given parameters"""

        batch_size = s_batch.shape[0]

        targets = np.zeros((batch_size, NUM_ACTIONS))



        for i in range(batch_size):

            targets[i] = self.model.predict(s_batch[i].reshape(1, 84, 84, NUM_FRAMES), batch_size = 1)

            fut_action = self.target_model.predict(s2_batch[i].reshape(1, 84, 84, NUM_FRAMES), batch_size = 1)

            targets[i, a_batch[i]] = r_batch[i]

            if d_batch[i] == False:

                targets[i, a_batch[i]] += DECAY_RATE * np.max(fut_action)



        loss = self.model.train_on_batch(s_batch, targets)



        # Print the loss every 10 iterations.

        if observation_num % 10 == 0:

            print("We had a loss equal to ", loss)

In my code (https://bitbucket.org/jocapal/dqn_public/src/master/Deimos_v2_13.py) I get a batch of 32 experiences; then make small batches of 4 experiences and feed the CNN. My question is: am I doing it wrong? And if so, how can I feed 32 experiences when my CNN is waiting for 4 experiences?

Another example of what I'm saying: https://yanpanlau.github.io/2016/07/10/FlappyBird-Keras.html

Input is a 4D tensor [batch_size, height, width, channels] . Single state is already 4 frames stacked together so when you sample a state from the experience replay you sample a 3D tensor [height, width, channels]. When you sample 32 states you actually sample 32 of those 3D tensors and feed them directly to the network. For more details on preprocessing refer to the page 6 of the original DQN paper found here.