Module monk.pytorch.finetune.level_9_transforms_main

Expand source code 
from pytorch.finetune.imports import *
from system.imports import *

from pytorch.finetune.level_8_layers_main import prototype_layers


class prototype_transforms(prototype_layers):
    '''
    Main class for all transforms in expert mode

    Args:
        verbose (int): Set verbosity levels
                        0 - Print Nothing
                        1 - Print desired details
    '''

    def __init__(self, verbose=1):
        super().__init__(verbose=verbose);


    ###############################################################################################################################################
    def apply_center_crop(self, input_size, train=False, val=False, test=False):
        '''
        Apply Center Cropping transformation

        Args:
            input_size (int, list): Crop size
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_center_crop(self.system_dict, input_size, train, val, test);
    ###############################################################################################################################################



    ###############################################################################################################################################
    def apply_color_jitter(self, brightness=0, contrast=0, saturation=0, hue=0, train=False, val=False, test=False):
        '''
        Apply Color jittering transformations

        Args:
            brightness (float): Levels to jitter brightness.
                                        0 - min
                                        1 - max
            contrast (float): Levels to jitter contrast.
                                        0 - min
                                        1 - max
            saturation (float): Levels to jitter saturation.
                                        0 - min
                                        1 - max
            hue (float): Levels to jitter hue.
                                        0 - min
                                        1 - max
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_color_jitter(self.system_dict, brightness, contrast, saturation, hue, train, val, test);
    ###############################################################################################################################################




    ###############################################################################################################################################
    def apply_random_affine(self, degrees, translate=None, scale=None, shear=None, train=False, val=False, test=False):
        '''
        Apply random affine transformations

        Args:
            degrees (float): Max Rotation range limit for transforms
            scale (float, list): Range for randomly scaling 
            shear (float, list): Range for randomly applying sheer changes
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_random_affine(self.system_dict, degrees, translate, scale, shear, train, val, test);
    ###############################################################################################################################################




    ###############################################################################################################################################
    def apply_random_crop(self, input_size, train=False, val=False, test=False):  
        '''
        Apply Random Cropping transformation

        Args:
            input_size (int, list): Crop size
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''  
        self.system_dict = transform_random_crop(self.system_dict, input_size, train, val, test);
    ###############################################################################################################################################



    ###############################################################################################################################################
    def apply_random_horizontal_flip(self, probability=0.5, train=False, val=False, test=False):
        '''
        Apply random horizontal flip transformations

        Args:
            probability (float): Probability of flipping the input image
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_random_horizontal_flip(self.system_dict, probability, train, val, test);
    ###############################################################################################################################################




    ###############################################################################################################################################
    def apply_random_perspective(self, distortion_scale=0.5, probability=0.5, train=False, val=False, test=False):
        '''
        Apply random perspective transformations

        Args:
            distortion_scale (float): Max limit for perspective distortion
            probability (float): Probability of applying transformation
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_random_perspective(self.system_dict, distortion_scale, probability, train, val, test);
    ###############################################################################################################################################





    ###############################################################################################################################################
    def apply_random_resized_crop(self, input_size, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), train=False, val=False, test=False):
        '''
        Apply Random Resized Cropping transformation

        Args:
            input_size (int, list): Crop size
            scale (float, tuple): scaling ratio limits; for maximum and minimum random scaling
            ratio (float, tuple): aspect ratio limits; for maximum and minmum changes to aspect ratios 
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_random_resized_crop(self.system_dict, input_size, scale, ratio, train, val, test);
    ###############################################################################################################################################




    ###############################################################################################################################################
    def apply_grayscale(self, num_output_channels=3, train=False, val=False, test=False):
        '''
        Not active
        '''
        self.system_dict = transform_grayscale(self.system_dict, num_output_channels, train, val, test);
    ###############################################################################################################################################




    ###############################################################################################################################################
    def apply_random_rotation(self, degrees, train=False, val=False, test=False):
        '''
        Apply random rotation transformations

        Args:
            degrees (float): Max Rotation range limit for transforms
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_random_rotation(self.system_dict, degrees, train, val, test);
    ###############################################################################################################################################



    ###############################################################################################################################################
    def apply_random_vertical_flip(self, probability=0.5, train=False, val=False, test=False):
        '''
        Apply random vertical flip transformations

        Args:
            probability (float): Probability of flipping the input image
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_random_vertical_flip(self.system_dict, probability, train, val, test);
    ###############################################################################################################################################



    ###############################################################################################################################################
    def apply_resize(self, input_size, train=False, val=False, test=False):
        '''
        Apply standard resizing

        Args:
            input_size (int, list): expected final size
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_resize_gluon(self.system_dict, input_size, train, val, test);
    ###############################################################################################################################################


    ###############################################################################################################################################
    def apply_normalize(self, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], train=False, val=False, test=False):
        '''
        Apply mean subtraction and standard normalization

        Args:
            mean (float, list): Mean value for subtraction
            std (float, list): Normalization factor
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_normalize(self.system_dict, mean, std, train, val, test);
    ###############################################################################################################################################

Classes

class prototype_transforms (verbose=1)

Main class for all transforms in expert mode

Args

verbose : int
Set verbosity levels 0 - Print Nothing 1 - Print desired details

Class that serves as a decorator to trace entry and exit from functions. Used by appending @TraceFunction on top of the definition of the function to trace.

Expand source code 
class prototype_transforms(prototype_layers):
    '''
    Main class for all transforms in expert mode

    Args:
        verbose (int): Set verbosity levels
                        0 - Print Nothing
                        1 - Print desired details
    '''

    def __init__(self, verbose=1):
        super().__init__(verbose=verbose);


    ###############################################################################################################################################
    def apply_center_crop(self, input_size, train=False, val=False, test=False):
        '''
        Apply Center Cropping transformation

        Args:
            input_size (int, list): Crop size
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_center_crop(self.system_dict, input_size, train, val, test);
    ###############################################################################################################################################



    ###############################################################################################################################################
    def apply_color_jitter(self, brightness=0, contrast=0, saturation=0, hue=0, train=False, val=False, test=False):
        '''
        Apply Color jittering transformations

        Args:
            brightness (float): Levels to jitter brightness.
                                        0 - min
                                        1 - max
            contrast (float): Levels to jitter contrast.
                                        0 - min
                                        1 - max
            saturation (float): Levels to jitter saturation.
                                        0 - min
                                        1 - max
            hue (float): Levels to jitter hue.
                                        0 - min
                                        1 - max
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_color_jitter(self.system_dict, brightness, contrast, saturation, hue, train, val, test);
    ###############################################################################################################################################




    ###############################################################################################################################################
    def apply_random_affine(self, degrees, translate=None, scale=None, shear=None, train=False, val=False, test=False):
        '''
        Apply random affine transformations

        Args:
            degrees (float): Max Rotation range limit for transforms
            scale (float, list): Range for randomly scaling 
            shear (float, list): Range for randomly applying sheer changes
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_random_affine(self.system_dict, degrees, translate, scale, shear, train, val, test);
    ###############################################################################################################################################




    ###############################################################################################################################################
    def apply_random_crop(self, input_size, train=False, val=False, test=False):  
        '''
        Apply Random Cropping transformation

        Args:
            input_size (int, list): Crop size
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''  
        self.system_dict = transform_random_crop(self.system_dict, input_size, train, val, test);
    ###############################################################################################################################################



    ###############################################################################################################################################
    def apply_random_horizontal_flip(self, probability=0.5, train=False, val=False, test=False):
        '''
        Apply random horizontal flip transformations

        Args:
            probability (float): Probability of flipping the input image
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_random_horizontal_flip(self.system_dict, probability, train, val, test);
    ###############################################################################################################################################




    ###############################################################################################################################################
    def apply_random_perspective(self, distortion_scale=0.5, probability=0.5, train=False, val=False, test=False):
        '''
        Apply random perspective transformations

        Args:
            distortion_scale (float): Max limit for perspective distortion
            probability (float): Probability of applying transformation
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_random_perspective(self.system_dict, distortion_scale, probability, train, val, test);
    ###############################################################################################################################################





    ###############################################################################################################################################
    def apply_random_resized_crop(self, input_size, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), train=False, val=False, test=False):
        '''
        Apply Random Resized Cropping transformation

        Args:
            input_size (int, list): Crop size
            scale (float, tuple): scaling ratio limits; for maximum and minimum random scaling
            ratio (float, tuple): aspect ratio limits; for maximum and minmum changes to aspect ratios 
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_random_resized_crop(self.system_dict, input_size, scale, ratio, train, val, test);
    ###############################################################################################################################################




    ###############################################################################################################################################
    def apply_grayscale(self, num_output_channels=3, train=False, val=False, test=False):
        '''
        Not active
        '''
        self.system_dict = transform_grayscale(self.system_dict, num_output_channels, train, val, test);
    ###############################################################################################################################################




    ###############################################################################################################################################
    def apply_random_rotation(self, degrees, train=False, val=False, test=False):
        '''
        Apply random rotation transformations

        Args:
            degrees (float): Max Rotation range limit for transforms
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_random_rotation(self.system_dict, degrees, train, val, test);
    ###############################################################################################################################################



    ###############################################################################################################################################
    def apply_random_vertical_flip(self, probability=0.5, train=False, val=False, test=False):
        '''
        Apply random vertical flip transformations

        Args:
            probability (float): Probability of flipping the input image
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_random_vertical_flip(self.system_dict, probability, train, val, test);
    ###############################################################################################################################################



    ###############################################################################################################################################
    def apply_resize(self, input_size, train=False, val=False, test=False):
        '''
        Apply standard resizing

        Args:
            input_size (int, list): expected final size
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_resize_gluon(self.system_dict, input_size, train, val, test);
    ###############################################################################################################################################


    ###############################################################################################################################################
    def apply_normalize(self, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], train=False, val=False, test=False):
        '''
        Apply mean subtraction and standard normalization

        Args:
            mean (float, list): Mean value for subtraction
            std (float, list): Normalization factor
            train (bool): If True, transform applied to training data
            val (bool): If True, transform applied to validation data
            test (bool): If True, transform applied to testing/inferencing data

        Returns:
            None
        '''
        self.system_dict = transform_normalize(self.system_dict, mean, std, train, val, test);

Ancestors

  • pytorch.finetune.level_8_layers_main.prototype_layers
  • pytorch.finetune.level_7_aux_main.prototype_aux
  • pytorch.finetune.level_6_params_main.prototype_params
  • pytorch.finetune.level_5_state_base.finetune_state
  • pytorch.finetune.level_4_evaluation_base.finetune_evaluation
  • pytorch.finetune.level_3_training_base.finetune_training
  • pytorch.finetune.level_2_model_base.finetune_model
  • pytorch.finetune.level_1_dataset_base.finetune_dataset
  • system.base_class.system

Methods

def apply_center_crop(self, input_size, train=False, val=False, test=False)

Apply Center Cropping transformation

Args

input_size : int, list
Crop size
train : bool
If True, transform applied to training data
val : bool
If True, transform applied to validation data
test : bool
If True, transform applied to testing/inferencing data

Returns

None
 
Expand source code 
def apply_center_crop(self, input_size, train=False, val=False, test=False):
    '''
    Apply Center Cropping transformation

    Args:
        input_size (int, list): Crop size
        train (bool): If True, transform applied to training data
        val (bool): If True, transform applied to validation data
        test (bool): If True, transform applied to testing/inferencing data

    Returns:
        None
    '''
    self.system_dict = transform_center_crop(self.system_dict, input_size, train, val, test);
def apply_color_jitter(self, brightness=0, contrast=0, saturation=0, hue=0, train=False, val=False, test=False)

Apply Color jittering transformations

Args

brightness : float
Levels to jitter brightness. 0 - min 1 - max
contrast : float
Levels to jitter contrast. 0 - min 1 - max
saturation : float
Levels to jitter saturation. 0 - min 1 - max
hue : float
Levels to jitter hue. 0 - min 1 - max
train : bool
If True, transform applied to training data
val : bool
If True, transform applied to validation data
test : bool
If True, transform applied to testing/inferencing data

Returns

None
 
Expand source code 
def apply_color_jitter(self, brightness=0, contrast=0, saturation=0, hue=0, train=False, val=False, test=False):
    '''
    Apply Color jittering transformations

    Args:
        brightness (float): Levels to jitter brightness.
                                    0 - min
                                    1 - max
        contrast (float): Levels to jitter contrast.
                                    0 - min
                                    1 - max
        saturation (float): Levels to jitter saturation.
                                    0 - min
                                    1 - max
        hue (float): Levels to jitter hue.
                                    0 - min
                                    1 - max
        train (bool): If True, transform applied to training data
        val (bool): If True, transform applied to validation data
        test (bool): If True, transform applied to testing/inferencing data

    Returns:
        None
    '''
    self.system_dict = transform_color_jitter(self.system_dict, brightness, contrast, saturation, hue, train, val, test);
def apply_grayscale(self, num_output_channels=3, train=False, val=False, test=False)

Not active

Expand source code 
def apply_grayscale(self, num_output_channels=3, train=False, val=False, test=False):
    '''
    Not active
    '''
    self.system_dict = transform_grayscale(self.system_dict, num_output_channels, train, val, test);
def apply_normalize(self, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], train=False, val=False, test=False)

Apply mean subtraction and standard normalization

Args

mean : float, list
Mean value for subtraction
std : float, list
Normalization factor
train : bool
If True, transform applied to training data
val : bool
If True, transform applied to validation data
test : bool
If True, transform applied to testing/inferencing data

Returns

None
 
Expand source code 
def apply_normalize(self, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], train=False, val=False, test=False):
    '''
    Apply mean subtraction and standard normalization

    Args:
        mean (float, list): Mean value for subtraction
        std (float, list): Normalization factor
        train (bool): If True, transform applied to training data
        val (bool): If True, transform applied to validation data
        test (bool): If True, transform applied to testing/inferencing data

    Returns:
        None
    '''
    self.system_dict = transform_normalize(self.system_dict, mean, std, train, val, test);
def apply_random_affine(self, degrees, translate=None, scale=None, shear=None, train=False, val=False, test=False)

Apply random affine transformations

Args

degrees : float
Max Rotation range limit for transforms
scale : float, list
Range for randomly scaling
shear : float, list
Range for randomly applying sheer changes
train : bool
If True, transform applied to training data
val : bool
If True, transform applied to validation data
test : bool
If True, transform applied to testing/inferencing data

Returns

None
 
Expand source code 
def apply_random_affine(self, degrees, translate=None, scale=None, shear=None, train=False, val=False, test=False):
    '''
    Apply random affine transformations

    Args:
        degrees (float): Max Rotation range limit for transforms
        scale (float, list): Range for randomly scaling 
        shear (float, list): Range for randomly applying sheer changes
        train (bool): If True, transform applied to training data
        val (bool): If True, transform applied to validation data
        test (bool): If True, transform applied to testing/inferencing data

    Returns:
        None
    '''
    self.system_dict = transform_random_affine(self.system_dict, degrees, translate, scale, shear, train, val, test);
def apply_random_crop(self, input_size, train=False, val=False, test=False)

Apply Random Cropping transformation

Args

input_size : int, list
Crop size
train : bool
If True, transform applied to training data
val : bool
If True, transform applied to validation data
test : bool
If True, transform applied to testing/inferencing data

Returns

None
 
Expand source code 
def apply_random_crop(self, input_size, train=False, val=False, test=False):  
    '''
    Apply Random Cropping transformation

    Args:
        input_size (int, list): Crop size
        train (bool): If True, transform applied to training data
        val (bool): If True, transform applied to validation data
        test (bool): If True, transform applied to testing/inferencing data

    Returns:
        None
    '''  
    self.system_dict = transform_random_crop(self.system_dict, input_size, train, val, test);
def apply_random_horizontal_flip(self, probability=0.5, train=False, val=False, test=False)

Apply random horizontal flip transformations

Args

probability : float
Probability of flipping the input image
train : bool
If True, transform applied to training data
val : bool
If True, transform applied to validation data
test : bool
If True, transform applied to testing/inferencing data

Returns

None
 
Expand source code 
def apply_random_horizontal_flip(self, probability=0.5, train=False, val=False, test=False):
    '''
    Apply random horizontal flip transformations

    Args:
        probability (float): Probability of flipping the input image
        train (bool): If True, transform applied to training data
        val (bool): If True, transform applied to validation data
        test (bool): If True, transform applied to testing/inferencing data

    Returns:
        None
    '''
    self.system_dict = transform_random_horizontal_flip(self.system_dict, probability, train, val, test);
def apply_random_perspective(self, distortion_scale=0.5, probability=0.5, train=False, val=False, test=False)

Apply random perspective transformations

Args

distortion_scale : float
Max limit for perspective distortion
probability : float
Probability of applying transformation
train : bool
If True, transform applied to training data
val : bool
If True, transform applied to validation data
test : bool
If True, transform applied to testing/inferencing data

Returns

None
 
Expand source code 
def apply_random_perspective(self, distortion_scale=0.5, probability=0.5, train=False, val=False, test=False):
    '''
    Apply random perspective transformations

    Args:
        distortion_scale (float): Max limit for perspective distortion
        probability (float): Probability of applying transformation
        train (bool): If True, transform applied to training data
        val (bool): If True, transform applied to validation data
        test (bool): If True, transform applied to testing/inferencing data

    Returns:
        None
    '''
    self.system_dict = transform_random_perspective(self.system_dict, distortion_scale, probability, train, val, test);
def apply_random_resized_crop(self, input_size, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), train=False, val=False, test=False)

Apply Random Resized Cropping transformation

Args

input_size : int, list
Crop size
scale : float, tuple
scaling ratio limits; for maximum and minimum random scaling
ratio : float, tuple
aspect ratio limits; for maximum and minmum changes to aspect ratios
train : bool
If True, transform applied to training data
val : bool
If True, transform applied to validation data
test : bool
If True, transform applied to testing/inferencing data

Returns

None
 
Expand source code 
def apply_random_resized_crop(self, input_size, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), train=False, val=False, test=False):
    '''
    Apply Random Resized Cropping transformation

    Args:
        input_size (int, list): Crop size
        scale (float, tuple): scaling ratio limits; for maximum and minimum random scaling
        ratio (float, tuple): aspect ratio limits; for maximum and minmum changes to aspect ratios 
        train (bool): If True, transform applied to training data
        val (bool): If True, transform applied to validation data
        test (bool): If True, transform applied to testing/inferencing data

    Returns:
        None
    '''
    self.system_dict = transform_random_resized_crop(self.system_dict, input_size, scale, ratio, train, val, test);
def apply_random_rotation(self, degrees, train=False, val=False, test=False)

Apply random rotation transformations

Args

degrees : float
Max Rotation range limit for transforms
train : bool
If True, transform applied to training data
val : bool
If True, transform applied to validation data
test : bool
If True, transform applied to testing/inferencing data

Returns

None
 
Expand source code 
def apply_random_rotation(self, degrees, train=False, val=False, test=False):
    '''
    Apply random rotation transformations

    Args:
        degrees (float): Max Rotation range limit for transforms
        train (bool): If True, transform applied to training data
        val (bool): If True, transform applied to validation data
        test (bool): If True, transform applied to testing/inferencing data

    Returns:
        None
    '''
    self.system_dict = transform_random_rotation(self.system_dict, degrees, train, val, test);
def apply_random_vertical_flip(self, probability=0.5, train=False, val=False, test=False)

Apply random vertical flip transformations

Args

probability : float
Probability of flipping the input image
train : bool
If True, transform applied to training data
val : bool
If True, transform applied to validation data
test : bool
If True, transform applied to testing/inferencing data

Returns

None
 
Expand source code 
def apply_random_vertical_flip(self, probability=0.5, train=False, val=False, test=False):
    '''
    Apply random vertical flip transformations

    Args:
        probability (float): Probability of flipping the input image
        train (bool): If True, transform applied to training data
        val (bool): If True, transform applied to validation data
        test (bool): If True, transform applied to testing/inferencing data

    Returns:
        None
    '''
    self.system_dict = transform_random_vertical_flip(self.system_dict, probability, train, val, test);
def apply_resize(self, input_size, train=False, val=False, test=False)

Apply standard resizing

Args

input_size : int, list
expected final size
train : bool
If True, transform applied to training data
val : bool
If True, transform applied to validation data
test : bool
If True, transform applied to testing/inferencing data

Returns

None
 
Expand source code 
def apply_resize(self, input_size, train=False, val=False, test=False):
    '''
    Apply standard resizing

    Args:
        input_size (int, list): expected final size
        train (bool): If True, transform applied to training data
        val (bool): If True, transform applied to validation data
        test (bool): If True, transform applied to testing/inferencing data

    Returns:
        None
    '''
    self.system_dict = transform_resize_gluon(self.system_dict, input_size, train, val, test);