📝 Fix :return: statements

InnerEye/Common/Statistics/mann_whitney_test.py

@@ -91,7 +91,7 @@ def compose_distribution_comparisons(file_contents: List[List[List[str]]]) -> Li
 
  :param file_contents: two or more lists of rows, where each "rows" is returned by read_csv_file on
  (typically) a statistics.csv file
- :return a list of lines to print
+ :return: a list of lines to print
  """
  value_lists: List[Dict[str, List[float]]] = [parse_values(rows) for rows in file_contents]
  return compose_distribution_comparisons_on_lists(value_lists)

InnerEye/ML/SSL/lightning_containers/ssl_container.py

@@ -203,7 +203,7 @@ def _create_ssl_data_modules(self, is_ssl_encoder_module: bool) -> InnerEyeVisio
  Returns torch lightning data module for encoder or linear head
 
  :param is_ssl_encoder_module: whether to return the data module for SSL training or for linear head. If true,
- :return transforms with two views per sample (batch like (img_v1, img_v2, label)). If False, return only one
+ :return: transforms with two views per sample (batch like (img_v1, img_v2, label)). If False, return only one
  view per sample but also return the index of the sample in the dataset (to make sure we don't use twice the same
  batch in one training epoch (batch like (index, img_v1, label), as classifier dataloader expected to be shorter
  than SSL training, hence CombinedDataloader might loop over data several times per epoch).

InnerEye/ML/SSL/lightning_containers/ssl_image_classifier.py

@@ -19,11 +19,11 @@ class SSLClassifierContainer(SSLContainer):
  """
  This module is used to train a linear classifier on top of a frozen (or not) encoder.
 
- If you are running on AML, you can specify the SSL training run id via the --pretraining_run_recovery_id flag. This
- will automatically download the checkpoints for you and take the latest one as the starting weights of your
+ If you are running on AML, you can specify the SSL training run id via the ``--pretraining_run_recovery_id`` flag.
+ This will automatically download the checkpoints for you and take the latest one as the starting weights of your
  classifier.
 
- If you are running locally, you can specify the path to your SSL weights via the --local_ssl_weights_path parameter.
+ If you are running locally, you can specify the path to your SSL weights via the ``--local_ssl_weights_path`` flag.
 
  See docs/self_supervised_models.md for more details.
  """

InnerEye/ML/SSL/lightning_modules/byol/byol_module.py

@@ -120,7 +120,10 @@ def setup(self, *args: Any, **kwargs: Any) -> None:
  self.train_iters_per_epoch = self.hparams.num_samples // global_batch_size # type: ignore
 
  def configure_optimizers(self) -> Any:
- # exclude certain parameters
+ """Testing this out
+
+ :return: _description_
+ """
  parameters = self.exclude_from_wt_decay(self.online_network.named_parameters(),
  weight_decay=self.hparams.weight_decay) # type: ignore
  optimizer = Adam(parameters,

InnerEye/ML/lightning_metrics.py

@@ -165,7 +165,7 @@ def _get_metrics_at_optimal_cutoff(self) -> Tuple[torch.Tensor, torch.Tensor, to
  difference between true positive rate and false positive rate is smallest. Then, computes
  the false positive rate, false negative rate and accuracy at this threshold (i.e. when the
  predicted probability is higher than the threshold the predicted label is 1 otherwise 0).
- :returns: Tuple(optimal_threshold, false positive rate, false negative rate, accuracy)
+ :return: Tuple(optimal_threshold, false positive rate, false negative rate, accuracy)
  """
  preds, targets = self._get_preds_and_targets()
  if torch.unique(targets).numel() == 1:

InnerEye/ML/metrics.py

@@ -226,7 +226,7 @@ def compute_dice_across_patches(segmentation: torch.Tensor,
  :param ground_truth: One-hot encoded torch tensor containing ground-truth label ids.
  :param allow_multiple_classes_for_each_pixel: If set to False, ground-truth tensor has
  to contain only one foreground label for each pixel.
- :return A torch tensor of size (Patches, Classes) with the Dice scores. Dice scores are computed for
+ :return: A torch tensor of size (Patches, Classes) with the Dice scores. Dice scores are computed for
  all classes including the background class at index 0.
  """
  check_size_matches(segmentation, ground_truth, 4, 5, [0, -3, -2, -1],

InnerEye/ML/metrics_dict.py

@@ -457,7 +457,7 @@ def get_metrics_at_optimal_cutoff(self, hue: str = DEFAULT_HUE_KEY) -> Tuple:
  predicted probability is higher than the threshold the predicted label is 1 otherwise 0).
 
  :param hue: The hue to restrict the values used for computation, otherwise all values will be used.
- :returns: Tuple(optimal_threshold, false positive rate, false negative rate, accuracy)
+ :return: Tuple(optimal_threshold, false positive rate, false negative rate, accuracy)
  """
  fpr, tpr, thresholds = roc_curve(self.get_labels(hue=hue), self.get_predictions(hue=hue))
  optimal_idx = MetricsDict.get_optimal_idx(fpr=fpr, tpr=tpr)

InnerEye/ML/model_testing.py

@@ -131,7 +131,7 @@ def segmentation_model_test_epoch(config: SegmentationModelBase,
  :param epoch_and_split: A string that should uniquely identify the epoch and the data split (train/val/test).
  :raises TypeError: If the arguments are of the wrong type.
  :raises ValueError: When there are issues loading the model.
- :return A list with the mean dice score (across all structures apart from background) for each image.
+ :return: A list with the mean dice score (across all structures apart from background) for each image.
  """
  ml_util.set_random_seed(config.get_effective_random_seed(), "Model testing")
  results_folder.mkdir(exist_ok=True)
@@ -212,7 +212,7 @@ def evaluate_model_predictions(process_id: int,
  :param config: Segmentation model config object
  :param dataset: Dataset object, it is used to load intensity image, labels, and patient metadata.
  :param results_folder: Path to results folder
- :returns [PatientMetadata, list[list]]: Patient metadata and list of computed metrics for each image.
+ :return: [PatientMetadata, list[list]]: Patient metadata and list of computed metrics for each image.
  """
  sample = dataset.get_samples_at_index(index=process_id)[0]
  logging.info(f"Evaluating predictions for patient {sample.patient_id}")
@@ -244,7 +244,7 @@ def populate_metrics_writer(
  from evaluate_model_predictions
 
  :param config: The SegmentationModelBase config from which we read the ground_truth_ids
- :returns: A new MetricsPerPatientWriter and a list of foreground DICE score averages
+ :return: A new MetricsPerPatientWriter and a list of foreground DICE score averages
  """
  average_dice: List[FloatOrInt] = []
  metrics_writer = MetricsPerPatientWriter()

InnerEye/ML/pipelines/ensemble.py

@@ -85,7 +85,7 @@ def predict_whole_image(self, image_channels: np.ndarray,
  :param voxel_spacing_mm: Voxel spacing to use for each dimension in (Z x Y x X) order
  :param mask: A binary image used to ignore results outside it in format: Z x Y x X.
  :param patient_id: The identifier of the patient this image belongs to.
- :return InferenceResult: that contains Segmentation for each of the classes and their posterior
+ :return: InferenceResult: that contains Segmentation for each of the classes and their posterior
  probabilities.
  """
  logging.info(f"Ensembling inference pipelines ({self._get_pipeline_ids()}) "

InnerEye/ML/pipelines/inference.py

@@ -206,7 +206,7 @@ def create_from_checkpoint(path_to_checkpoint: Path,
  :param model_config: Model related configurations.
  :param pipeline_id: Numeric identifier for the pipeline (useful for logging when ensembling)
 
- :returns InferencePipeline: an instantiated inference pipeline instance, or None if there was no checkpoint
+ :return: InferencePipeline: an instantiated inference pipeline instance, or None if there was no checkpoint
  file for this epoch.
  """
  if not path_to_checkpoint.is_file():
@@ -247,7 +247,7 @@ def predict_whole_image(self, image_channels: np.ndarray,
  :param voxel_spacing_mm: Voxel spacing to use for each dimension in (Z x Y x X) order
  :param mask: A binary image used to ignore results outside it in format: Z x Y x X.
  :param patient_id: The identifier of the patient this image belongs to (defaults to 0 if None provided).
- :return InferenceResult: that contains Segmentation for each of the classes and their posterior probabilities.
+ :return: InferenceResult: that contains Segmentation for each of the classes and their posterior probabilities.
  """
  torch.cuda.empty_cache()
  if image_channels is None:

InnerEye/ML/run_ml.py

@@ -529,7 +529,7 @@ def register_model(self,
 
  :param checkpoint_paths: Checkpoint paths to register.
  :param model_proc: whether it's a single or ensemble model.
- :returns Tuple element 1: AML model object, or None if no model could be registered.
+ :return: Tuple element 1: AML model object, or None if no model could be registered.
  Tuple element 2: The result of running the model_deployment_hook, or None if no hook was supplied.
  """
  if self.is_offline_run:

InnerEye/ML/utils/dataset_util.py

@@ -75,7 +75,7 @@ def encode(self, x: Dict[str, List[str]]) -> torch.Tensor:
 
  def get_supported_dataset_column_names(self) -> List[str]:
  """
- :returns list of categorical columns that are supported by this encoder
+ :return: list of categorical columns that are supported by this encoder
  """
  return list(self._columns_and_possible_categories.keys())
 
@@ -87,7 +87,7 @@ def get_feature_length(self, feature_name: str) -> int:
 
  :param feature_name: the name of the column for which to compute the feature
  length.
- :returns the feature length i.e. number of possible values for this feature.
+ :return: the feature length i.e. number of possible values for this feature.
  """
  return self._feature_length[feature_name]
 

InnerEye/ML/utils/device_aware_module.py

@@ -24,21 +24,21 @@ def __init__(self) -> None:
 
  def get_devices(self) -> List[torch.device]:
  """
- :return a list of device ids on which this module
+ :return: a list of device ids on which this module
  is deployed.
  """
  return list({x.device for x in self.parameters()})
 
  def get_number_trainable_parameters(self) -> int:
  """
- :return the number of trainable parameters in the module.
+ :return: the number of trainable parameters in the module.
  """
  return sum(p.numel() for p in self.parameters() if p.requires_grad)
 
  def is_model_on_gpu(self) -> bool:
  """
  Checks if the model is cuda activated or not
- :return True if the model is running on the GPU.
+ :return: True if the model is running on the GPU.
  """
  try:
  cuda_activated = next(self.parameters()).is_cuda

InnerEye/ML/utils/features_util.py

@@ -88,7 +88,7 @@ def standardize(self, sources: List[ScalarDataSource]) -> List[ScalarDataSource]
  All features that have zero standard deviation (constant features) are left untouched.
 
  :param sources: list of datasources.
- :return list of data sources where all non-imaging features are standardized.
+ :return: list of data sources where all non-imaging features are standardized.
  """
 
  def apply_source(source: ScalarDataSource) -> ScalarDataSource:

InnerEye/ML/utils/image_util.py

@@ -76,7 +76,7 @@ def apply_mask_to_posteriors(posteriors: NumpyOrTorch, mask: NumpyOrTorch) -> Nu
 
  :param posteriors: image tensors in shape: Batches (optional) x Classes x Z x Y x X
  :param mask: image tensor in shape: Batches (optional) x Z x Y x X
- :return posteriors with mask applied
+ :return: posteriors with mask applied
  """
  ml_util.check_size_matches(posteriors, mask, matching_dimensions=[-1, -2, -3])
 
@@ -211,7 +211,7 @@ def posteriors_to_segmentation(posteriors: NumpyOrTorch) -> NumpyOrTorch:
 
  :param posteriors: Confidence maps [0,1] for each patch per class in format: Batches x Class x Z x Y x X
  or Class x Z x Y x X for non-batched input
- :returns segmentation: argmaxed posteriors with each voxel belonging to a single class: Batches x Z x Y x X
+ :return: segmentation: argmaxed posteriors with each voxel belonging to a single class: Batches x Z x Y x X
  or Z x Y x X for non-batched input
  """
 
@@ -374,7 +374,7 @@ def get_center_crop(image: NumpyOrTorch, crop_shape: TupleInt3) -> NumpyOrTorch:
 
  :param image: The original image to extract crop from
  :param crop_shape: The shape of the center crop to extract
- :return the center region as specified by the crop_shape argument.
+ :return: the center region as specified by the crop_shape argument.
  """
  if image is None or crop_shape is None:
  raise Exception("image and crop_shape must not be None")

InnerEye/ML/utils/layer_util.py

@@ -48,7 +48,7 @@ def get_padding_from_kernel_size(padding: PaddingMode,
 
  :param num_dimensions: The number of dimensions that the returned padding tuple should have, if both
  kernel_size and dilation are scalars.
- :return padding value required for convolution layers based on input kernel size and dilation.
+ :return: padding value required for convolution layers based on input kernel size and dilation.
  """
  if isinstance(kernel_size, Sized):
  num_dimensions = len(kernel_size)

InnerEye/ML/utils/metrics_util.py

@@ -256,7 +256,7 @@ def convert_input_and_label(model_output: Union[torch.Tensor, np.ndarray],
  label: Union[torch.Tensor, np.ndarray]) -> Tuple[torch.Tensor, torch.Tensor]:
  """
  Ensures that both model_output and label are tensors of dtype float32.
- :return a Tuple with model_output, label as float tensors.
+ :return: a Tuple with model_output, label as float tensors.
  """
  if not torch.is_tensor(model_output):
  model_output = torch.tensor(model_output)
@@ -273,6 +273,6 @@ def is_missing_ground_truth(ground_truth: np.ndarray) -> bool:
 
  :param ground_truth: ground truth binary array with dimensions: [Z x Y x X].
  :param label_id: Integer index of the label to check.
- :returns: True if the label is missing (signified by NaN), False otherwise.
+ :return: True if the label is missing (signified by NaN), False otherwise.
  """
  return np.isnan(ground_truth[0, 0, 0])

InnerEye/ML/utils/ml_util.py

@@ -175,7 +175,7 @@ def is_test_from_execution_mode(execution_mode: ModelExecutionMode) -> bool:
  """
  Returns a boolean by checking the execution type. The output is used to determine the properties
  of the forward pass, e.g. model gradient updates or metric computation.
- :return True if execution mode is VAL or TEST, False if TRAIN
+ :return: True if execution mode is VAL or TEST, False if TRAIN
  :raise ValueError if the execution mode is invalid
  """
  if execution_mode == ModelExecutionMode.TRAIN:

InnerEye/ML/utils/surface_distance_utils.py

@@ -97,7 +97,7 @@ def get_run_output_dir(azure_config: AzureConfig, model_config: SegmentationMode
 
  :param azure_config:
  :param model_config:
- :return output_dir: directory that all artifact paths use as a prefix
+ :return: output_dir: directory that all artifact paths use as a prefix
  """
  if not azure_config.run_recovery_id:
  raise ValueError("azure_config.run_recovery_id is not provided")
@@ -150,7 +150,7 @@ def get_subject_prefix(model_config: SegmentationModelBase, train_mode: ModelExe
  :param model_config: Config
  :param train_mode: Model execution mode -i.e. train, test or val
  :param subject_id: ID of the subject
- :return prefix: the filepath prefix within the container from which to download all artifacts
+ :return: prefix: the filepath prefix within the container from which to download all artifacts
  """
  prefix = model_config.outputs_folder / BEST_EPOCH_FOLDER_NAME / train_mode.value / "{0:03d}".format(subject_id)
  return prefix

InnerEye/ML/utils/temperature_scaling.py

@@ -63,7 +63,7 @@ def set_temperature(self,
  :param labels: Labels to use to learn the temperature parameter
  :param criterion_fn: A criterion function s.t: (logits, labels) => (loss, ECE)
  :param use_gpu: If True then GPU will be used otherwise CPU will be used.
- :return Optimal temperature value
+ :return: Optimal temperature value
  """
  if use_gpu:
  logits = logits.cuda()

InnerEye/ML/visualizers/model_summary.py

@@ -219,7 +219,7 @@ def forward_preserve_state(module: DeviceAwareModule, inputs: List[torch.Tensor]
 
  :param module: Callable torch module
  :param inputs: List of input torch tensors
- :return output: Output torch tensors
+ :return: output: Output torch tensors
  """
  if not isinstance(inputs, list):
  raise RuntimeError("Inputs object has to be a list of torch tensors")

Tests/ML/util.py

@@ -222,7 +222,7 @@ def csv_column_contains_value(
  :param column_name: The name of the column in which we look for the value
  :param value: The value to look for
  :param contains_only_value: Check that this is the only value in the column (default True)
- :returns: Boolean, whether the CSV column contains the value (and perhaps only the value)
+ :return: Boolean, whether the CSV column contains the value (and perhaps only the value)
  """
  result = True
  if not csv_file_path.exists:

docs/source/conf.py

@@ -61,7 +61,7 @@
 
 # -- Options for HTML output -------------------------------------------------
 
-# The theme to use for HTML and HTML Help pages. See the documentation fora
+# The theme to use for HTML and HTML Help pages. See the documentation for
 # a list of builtin themes.
 #
 html_theme = 'furo'