code: def forward(self, X, training=False, device='cpu'):
          
          y_infer = list(self.forward_iter(X, training=training, device=device))
  
          is_multioutput = len(y_infer) > 0 and isinstance(y_infer[0], tuple)
          if is_multioutput:
              return tuple(map(torch.cat, zip(*y_infer)))
          return torch.cat(y_infer)
docs: Gather and concatenate the output from forward call with
          input data.
  
          The outputs from ``self.module_.forward`` are gathered on the
          compute device specified by ``device`` and then concatenated
          using PyTorch :func:`~torch.cat`. If multiple outputs are
          returned by ``self.module_.forward``, each one of them must be
          able to be concatenated this way.
  
          Parameters
          ----------
          X : input data, compatible with skorch.dataset.Dataset
            By default, you should be able to pass:
  
              * numpy arrays
              * torch tensors
              * pandas DataFrame or Series
              * scipy sparse CSR matrices
              * a dictionary of the former three
              * a list/tuple of the former three
              * a Dataset
  
            If this doesn't work with your data, you have to pass a
            ``Dataset`` that can deal with the data.
  
          training : bool (default=False)
            Whether to set the module to train mode or not.
  
          device : string (default='cpu')
            The device to store each inference result on.
            This defaults to CPU memory since there is genereally
            more memory available there. For performance reasons
            this might be changed to a specific CUDA device,
            e.g. 'cuda:0'.
  
          Returns
          -------
          y_infer : torch tensor
            The result from the forward step.