class_docstr: A hyper-network to generate paramters for mixing model.
      
docstr: Args:
      agent_qs: (batch_size, T, n_agents)
      states:   (batch_size, T, state_shape)
  Returns:
      q_total: global q value
docstr_tok: ["Args",":","agent_qs",":","(","batch_size",",","T",",","n_agents",")","states",":","(","batch_size",",","T",",","state_shape",")","Returns",":","q_total",":","global","q","value"]
code: def forward(self, agent_qs, states):
      """
      Args:
          agent_qs: (batch_size, T, n_agents)
          states:   (batch_size, T, state_shape)
      Returns:
          q_total: global q value
      """
      episode_len = self.episode_limit - 1
      assert agent_qs.shape[1] == episode_len
      states = fluid.layers.reshape(
          states,
          shape=(self.batch_size * episode_len, self.state_shape),
      )
      agent_qs = fluid.layers.reshape(
          agent_qs,
          shape=(self.batch_size * episode_len, 1, self.n_agents),
      )
  
      if self.hypernet_layers == 1:
          w1 = self.hyper_w_1(states)
          w2 = self.hyper_w_2(states)
      elif self.hypernet_layers == 2:
          w1 = self.hyper_w_1_2(
              fluid.layers.relu(self.hyper_w_1_1(states))
          )
          w2 = self.hyper_w_2_2(
              fluid.layers.relu(self.hyper_w_2_1(states))
          )
      else:
          pass
  
      w1 = fluid.layers.abs(w1)
      w1 = fluid.layers.reshape(
          w1,
          shape=(
              self.batch_size * episode_len,
              self.n_agents,
              self.embed_dim,
          ),
      )
      w2 = fluid.layers.abs(w2)
      w2 = fluid.layers.reshape(
          w2, shape=(self.batch_size * episode_len, self.embed_dim, 1)
      )
  
      b1 = self.hyper_b_1(states)
      b1 = fluid.layers.reshape(
          b1, shape=(self.batch_size * episode_len, 1, self.embed_dim)
      )
  
      b2 = self.hyper_b_2_1(states)
      b2 = fluid.layers.relu(b2)
      b2 = self.hyper_b_2_2(b2)
      b2 = fluid.layers.reshape(
          b2, shape=(self.batch_size * episode_len, 1, 1)
      )
  
      hidden = fluid.layers.elu(fluid.layers.matmul(agent_qs, w1) + b1)
      y = fluid.layers.matmul(hidden, w2) + b2
      q_total = fluid.layers.reshape(
          y, shape=(self.batch_size, episode_len, 1)
      )
      return q_total
  
imports: import parl
  from parl import layers
  import paddle.fluid
label_desc: Use image node_id 2 for calling the QMixerModel obj's underlying member method code with example usage: obj.forward(agent_qs, states) and returns: q_total