class_docstr: Converts observations from an environment with multiple observations for use in a neural network
  policy.
  
  In some cases, you have environments that return multiple different observations per timestep 
  (in a robotics context, for example, a camera may be used to view the scene and a joint encoder may
  be used to report the angles for each joint). Usually, this can be handled by a policy that has
  multiple inputs, one for each modality. However, observations are returned by the environment
  in the form of a tuple `[(modality1_t, modality2_t, ..., modalityn_t) for t in T]` but the neural network
  expects them in per-modality batches like so: `[[modality1_1, ..., modality1_T], ..., [[modalityn_1, ..., modalityn_T]]`.
  This processor converts observations appropriate for this use case.
  
  # Arguments
      nb_inputs (integer): The number of inputs, that is different modalities, to be used.
          Your neural network that you use for the policy must have a corresponding number of
          inputs.
code: def process_state_batch(self, state_batch):
      input_batches = [[] for x in range(self.nb_inputs)]
      for state in state_batch:
          processed_state = [[] for x in range(self.nb_inputs)]
          for observation in state:
              assert len(observation) == self.nb_inputs
              for o, s in zip(observation, processed_state):
                  s.append(o)
          for idx, s in enumerate(processed_state):
              input_batches[idx].append(s)
      return [np.array(x) for x in input_batches]
  
file_path: keras-rl/rl/processors.py
imports: import numpy
  from rl.core import Processor
  from rl.util import WhiteningNormalizer
label_desc: Use image node_id 2 for calling the MultiInputProcessor obj's underlying member method code with example usage: obj.process_state_batch(state_batch) and returns: unknown