class_docstr: This class defines an application for image-level classification
  problems mapping from images to scalar labels.
  
  This is the application class to be instantiated by the driver
  and referred to in configuration files.
  
  Although structurally similar to segmentation, this application
  supports different samplers/aggregators (because patch-based
  processing is not appropriate), and monitoring metrics.
code: def initialise_dataset_loader(
      self, data_param=None, task_param=None, data_partitioner=None
  ):
      self.data_param = data_param
      self.classification_param = task_param
  
      if self.is_training:
          reader_names = ("image", "label", "sampler")
      elif self.is_inference:
          reader_names = ("image",)
      elif self.is_evaluation:
          reader_names = ("image", "label", "inferred")
      else:
          tf.logging.fatal(
              "Action `%s` not supported. Expected one of %s",
              self.action,
              self.SUPPORTED_PHASES,
          )
          raise ValueError
      try:
          reader_phase = self.action_param.dataset_to_infer
      except AttributeError:
          reader_phase = None
      file_lists = data_partitioner.get_file_lists_by(
          phase=reader_phase, action=self.action
      )
      self.readers = [
          ImageReader(reader_names).initialise(
              data_param, task_param, file_list
          )
          for file_list in file_lists
      ]
  
      foreground_masking_layer = (
          BinaryMaskingLayer(
              type_str=self.net_param.foreground_type,
              multimod_fusion=self.net_param.multimod_foreground_type,
              threshold=0.0,
          )
          if self.net_param.normalise_foreground_only
          else None
      )
  
      mean_var_normaliser = (
          MeanVarNormalisationLayer(
              image_name="image",
              binary_masking_func=foreground_masking_layer,
          )
          if self.net_param.whitening
          else None
      )
      histogram_normaliser = (
          HistogramNormalisationLayer(
              image_name="image",
              modalities=vars(task_param).get("image"),
              model_filename=self.net_param.histogram_ref_file,
              binary_masking_func=foreground_masking_layer,
              norm_type=self.net_param.norm_type,
              cutoff=self.net_param.cutoff,
              name="hist_norm_layer",
          )
          if (
              self.net_param.histogram_ref_file
              and self.net_param.normalisation
          )
          else None
      )
  
      label_normaliser = (
          DiscreteLabelNormalisationLayer(
              image_name="label",
              modalities=vars(task_param).get("label"),
              model_filename=self.net_param.histogram_ref_file,
          )
          if (
              self.net_param.histogram_ref_file
              and task_param.label_normalisation
          )
          else None
      )
  
      normalisation_layers = []
      if histogram_normaliser is not None:
          normalisation_layers.append(histogram_normaliser)
      if mean_var_normaliser is not None:
          normalisation_layers.append(mean_var_normaliser)
      if label_normaliser is not None:
          normalisation_layers.append(label_normaliser)
  
      augmentation_layers = []
      if self.is_training:
          train_param = self.action_param
          if train_param.random_flipping_axes != -1:
              augmentation_layers.append(
                  RandomFlipLayer(
                      flip_axes=train_param.random_flipping_axes
                  )
              )
          if train_param.scaling_percentage:
              augmentation_layers.append(
                  RandomSpatialScalingLayer(
                      min_percentage=train_param.scaling_percentage[0],
                      max_percentage=train_param.scaling_percentage[1],
                      antialiasing=train_param.antialiasing,
                      isotropic=train_param.isotropic_scaling,
                  )
              )
          if (
              train_param.rotation_angle
              or self.action_param.rotation_angle_x
              or self.action_param.rotation_angle_y
              or self.action_param.rotation_angle_z
          ):
              rotation_layer = RandomRotationLayer()
              if train_param.rotation_angle:
                  rotation_layer.init_uniform_angle(
                      train_param.rotation_angle
                  )
              else:
                  rotation_layer.init_non_uniform_angle(
                      self.action_param.rotation_angle_x,
                      self.action_param.rotation_angle_y,
                      self.action_param.rotation_angle_z,
                  )
              augmentation_layers.append(rotation_layer)
  
      # only add augmentation to first reader (not validation reader)
      self.readers[0].add_preprocessing_layers(
          normalisation_layers + augmentation_layers
      )
  
      for reader in self.readers[1:]:
          reader.add_preprocessing_layers(normalisation_layers)
  
      # Checking num_classes is set correctly
      if self.classification_param.num_classes <= 1:
          raise ValueError(
              "Number of classes must be at least 2 for classification"
          )
      for preprocessor in self.readers[0].preprocessors:
          if preprocessor.name == "label_norm":
              if (
                  len(preprocessor.label_map[preprocessor.key[0]])
                  != self.classification_param.num_classes
              ):
                  raise ValueError(
                      "Number of unique labels must be equal to "
                      "number of classes (check histogram_ref file)"
                  )
  
imports: import os
  import tensorflow
  from niftynet.application.base_application import BaseApplication
  from niftynet.engine.application_factory import ApplicationNetFactory, InitializerFactory, OptimiserFactory
  from niftynet.engine.application_variables import CONSOLE, NETWORK_OUTPUT, TF_SUMMARIES
  from niftynet.engine.sampler_resize_v2 import ResizeSampler
  from niftynet.engine.windows_aggregator_resize import ResizeSamplesAggregator
  from niftynet.engine.windows_aggregator_grid import GridSamplesAggregator
  from niftynet.io.image_reader import ImageReader
  from niftynet.layer.discrete_label_normalisation import DiscreteLabelNormalisationLayer
  from niftynet.layer.histogram_normalisation import HistogramNormalisationLayer
  from niftynet.layer.binary_masking import BinaryMaskingLayer
  from niftynet.layer.post_processing import PostProcessingLayer
  from niftynet.layer.loss_classification import LossFunction
  from niftynet.layer.mean_variance_normalisation import MeanVarNormalisationLayer
  from niftynet.layer.rand_flip import RandomFlipLayer
  from niftynet.layer.rand_rotation import RandomRotationLayer
  from niftynet.layer.rand_spatial_scaling import RandomSpatialScalingLayer
  from niftynet.evaluation.classification_evaluator import ClassificationEvaluator
label_desc: Use image node_id 2 for calling the ClassificationApplication obj's underlying member method code with example usage: obj.initialise_dataset_loader(data_param, task_param, data_partitioner) without return types