code: def create_supervised_evaluator(model, metrics=None,
                                  device=None, non_blocking=False,
                                  prepare_batch=_prepare_batch,
                                  output_transform=lambda x, y, y_pred: (y_pred, y,)):
      
      metrics = metrics or {}
  
      if device:
          model.to(device)
  
      def _inference(engine, batch):
          model.eval()
          with torch.no_grad():
              x, y = prepare_batch(batch, device=device, non_blocking=non_blocking)
              y_pred = model(x)
              return output_transform(x, y, y_pred)
  
      engine = Engine(_inference)
  
      for name, metric in metrics.items():
          metric.attach(engine, name)
  
      return engine
docs: Factory function for creating an evaluator for supervised models.
  
      Args:
          model (`torch.nn.Module`): the model to train.
          metrics (dict of str - :class:`~ignite.metrics.Metric`): a map of metric names to Metrics.
          device (str, optional): device type specification (default: None).
              Applies to both model and batches.
          non_blocking (bool, optional): if True and this copy is between CPU and GPU, the copy may occur asynchronously
              with respect to the host. For other cases, this argument has no effect.
          prepare_batch (callable, optional): function that receives `batch`, `device`, `non_blocking` and outputs
              tuple of tensors `(batch_x, batch_y)`.
          output_transform (callable, optional): function that receives 'x', 'y', 'y_pred' and returns value
              to be assigned to engine's state.output after each iteration. Default is returning `(y_pred, y,)` which fits
              output expected by metrics. If you change it you should use `output_transform` in metrics.
  
      Note: `engine.state.output` for this engine is defind by `output_transform` parameter and is
          a tuple of `(batch_pred, batch_y)` by default.
  
      Returns:
          Engine: an evaluator engine with supervised inference function.