Method __init__

rl2/atari/dqn_theano.py:224–300

(self, K, conv_layer_sizes, hidden_layer_sizes)

class DQN:
  def __init__(self, K, conv_layer_sizes, hidden_layer_sizes):
    self.K = K

    # inputs and targets
    X = T.ftensor4('X')
    G = T.fvector('G')
    actions = T.ivector('actions')

    # create the graph
    self.conv_layers = []
    num_input_filters = 4 # number of filters / color channels
    current_size = IM_SIZE
    for num_output_filters, filtersz, stride in conv_layer_sizes:
      ### not using this currently, it didn't make a difference ###
      # cut = None
      # if filtersz % 2 == 0: # if even
      #   cut = (current_size + stride - 1) // stride
      layer = ConvLayer(num_input_filters, num_output_filters, filtersz, stride)
      current_size = (current_size + stride - 1) // stride
      # print("current_size:", current_size)
      self.conv_layers.append(layer)
      num_input_filters = num_output_filters

    # get conv output size
    Z = X / 255.0
    for layer in self.conv_layers:
      Z = layer.forward(Z)
    conv_out = Z.flatten(ndim=2)
    conv_out_op = theano.function(inputs=[X], outputs=conv_out, allow_input_downcast=True)
    test = conv_out_op(np.random.randn(1, 4, IM_SIZE, IM_SIZE))
    flattened_ouput_size = test.shape[1]


    # build fully connected layers
    self.layers = []
    M1 = flattened_ouput_size
    print("flattened_ouput_size:", flattened_ouput_size)
    for M2 in hidden_layer_sizes:
      layer = HiddenLayer(M1, M2)
      self.layers.append(layer)
      M1 = M2

    # final layer
    layer = HiddenLayer(M1, K, lambda x: x)
    self.layers.append(layer)

    # collect params for copy
    self.params = []
    for layer in (self.conv_layers + self.layers):
      self.params += layer.params
    

    # calculate final output and cost
    Z = conv_out
    for layer in self.layers:
      Z = layer.forward(Z)
    Y_hat = Z