fastMONAI 0.3.1__tar.gz → 0.3.3__tar.gz

fastMONAI-0.3.3/CONTRIBUTING.md

@@ -0,0 +1,11 @@
+# How to contribute
+Contributions to the source code are greatly appreciated. If you find any issues or have suggestions for improvements, please open an issue in the corresponding GitHub repository. To contribute code changes, we encourage you to follow these [steps](https://docs.github.com/en/get-started/quickstart/contributing-to-projects). 
+
+## Getting Started
+1. Install an editable version of the forked project: `pip install -e 'fastMONAI[dev]'`
+2. Git hooks are used to run automatic scripts during each commit and merge to strip the notebooks of superfluous metadata and avoid merge conflicts. To set up Git hooks, run the following command inside the project folder: `nbdev_install_hooks`
+3. Once you have installed the project and set up the Git hooks, you can start making changes to the notebooks.
+4. Run: `nbdev_prepare` to build .py modules from notebooks and test them (if unit tests are written). 
+
+## Contact
+If you have any questions or need further assistance, please contact us at [skaliyugarasan@hotmail.com]. We appreciate your interest and look forward to your contributions.

{fastMONAI-0.3.1/fastMONAI.egg-info → fastMONAI-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastMONAI
-Version: 0.3.1
+Version: 0.3.3
 Summary: fastMONAI library
 Home-page: https://github.com/MMIV-ML/fastMONAI
 Author: Satheshkumar Kaliyugarasan

fastMONAI-0.3.3/fastMONAI/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.3"

{fastMONAI-0.3.1 → fastMONAI-0.3.3}/fastMONAI/_modidx.py

@@ -29,16 +29,18 @@ d = { 'settings': { 'branch': 'master',
                                                                                                'fastMONAI/external_data.py'),
                                          'fastMONAI.external_data._process_ixi_xls': ( 'external_data.html#_process_ixi_xls',
                                                                                        'fastMONAI/external_data.py'),
-                                         'fastMONAI.external_data._process_nodule_img': ( 'external_data.html#_process_nodule_img',
-                                                                                          'fastMONAI/external_data.py'),
-                                         'fastMONAI.external_data.download_NoduleMNIST3D': ( 'external_data.html#download_nodulemnist3d',
-                                                                                             'fastMONAI/external_data.py'),
+                                         'fastMONAI.external_data._process_medmnist_img': ( 'external_data.html#_process_medmnist_img',
+                                                                                            'fastMONAI/external_data.py'),
+                                         'fastMONAI.external_data.download_example_endometrial_cancer_data': ( 'external_data.html#download_example_endometrial_cancer_data',
+                                                                                                               'fastMONAI/external_data.py'),
                                          'fastMONAI.external_data.download_example_spine_data': ( 'external_data.html#download_example_spine_data',
                                                                                                   'fastMONAI/external_data.py'),
                                          'fastMONAI.external_data.download_ixi_data': ( 'external_data.html#download_ixi_data',
                                                                                         'fastMONAI/external_data.py'),
                                          'fastMONAI.external_data.download_ixi_tiny': ( 'external_data.html#download_ixi_tiny',
                                                                                         'fastMONAI/external_data.py'),
+                                         'fastMONAI.external_data.download_medmnist3d_dataset': ( 'external_data.html#download_medmnist3d_dataset',
+                                                                                                  'fastMONAI/external_data.py'),
                                          'fastMONAI.external_data.download_spine_test_data': ( 'external_data.html#download_spine_test_data',
                                                                                                'fastMONAI/external_data.py')},
             'fastMONAI.research_utils': { 'fastMONAI.research_utils.pred_postprocess': ( 'research_utils.html#pred_postprocess',
@@ -131,22 +133,6 @@ d = { 'settings': { 'branch': 'master',
                                                                                                           'fastMONAI/vision_augmentation.py'),
                                                'fastMONAI.vision_augmentation.ZNormalization.encodes': ( 'vision_augment.html#znormalization.encodes',
                                                                                                          'fastMONAI/vision_augmentation.py'),
-                                               'fastMONAI.vision_augmentation._do_rand_biasfield': ( 'vision_augment.html#_do_rand_biasfield',
-                                                                                                     'fastMONAI/vision_augmentation.py'),
-                                               'fastMONAI.vision_augmentation._do_rand_blur': ( 'vision_augment.html#_do_rand_blur',
-                                                                                                'fastMONAI/vision_augmentation.py'),
-                                               'fastMONAI.vision_augmentation._do_rand_gamma': ( 'vision_augment.html#_do_rand_gamma',
-                                                                                                 'fastMONAI/vision_augmentation.py'),
-                                               'fastMONAI.vision_augmentation._do_rand_ghosting': ( 'vision_augment.html#_do_rand_ghosting',
-                                                                                                    'fastMONAI/vision_augmentation.py'),
-                                               'fastMONAI.vision_augmentation._do_rand_motion': ( 'vision_augment.html#_do_rand_motion',
-                                                                                                  'fastMONAI/vision_augmentation.py'),
-                                               'fastMONAI.vision_augmentation._do_rand_noise': ( 'vision_augment.html#_do_rand_noise',
-                                                                                                 'fastMONAI/vision_augmentation.py'),
-                                               'fastMONAI.vision_augmentation._do_rand_spike': ( 'vision_augment.html#_do_rand_spike',
-                                                                                                 'fastMONAI/vision_augmentation.py'),
-                                               'fastMONAI.vision_augmentation._do_z_normalization': ( 'vision_augment.html#_do_z_normalization',
-                                                                                                      'fastMONAI/vision_augmentation.py'),
                                                'fastMONAI.vision_augmentation.do_pad_or_crop': ( 'vision_augment.html#do_pad_or_crop',
                                                                                                  'fastMONAI/vision_augmentation.py')},
             'fastMONAI.vision_core': { 'fastMONAI.vision_core.MedBase': ('vision_core.html#medbase', 'fastMONAI/vision_core.py'),

fastMONAI-0.3.3/fastMONAI/dataset_info.py

@@ -0,0 +1,122 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/08_dataset_info.ipynb.
+
+# %% auto 0
+__all__ = ['MedDataset', 'get_class_weights']
+
+# %% ../nbs/08_dataset_info.ipynb 2
+from .vision_core import *
+
+from sklearn.utils.class_weight import compute_class_weight
+from concurrent.futures import ThreadPoolExecutor
+import pandas as pd
+import numpy as np
+import torch
+import glob
+
+# %% ../nbs/08_dataset_info.ipynb 4
+class MedDataset:
+    """A class to extract and present information about the dataset."""
+
+    def __init__(self, path=None, postfix: str = '', img_list: list = None,
+                 reorder: bool = False, dtype: (MedImage, MedMask) = MedImage,
+                 max_workers: int = 1):
+        """Constructs MedDataset object.
+
+        Args:
+            path (str, optional): Path to the image folder.
+            postfix (str, optional): Specify the file type if there are different files in the folder.
+            img_list (List[str], optional): Alternatively, pass in a list with image paths.
+            reorder (bool, optional): Whether to reorder the data to be closest to canonical (RAS+) orientation.
+            dtype (Union[MedImage, MedMask], optional): Load data as datatype. Default is MedImage.
+            max_workers (int, optional): The number of worker threads. Default is 1.
+        """
+                     
+        self.path = path
+        self.postfix = postfix
+        self.img_list = img_list
+        self.reorder = reorder
+        self.dtype = dtype
+        self.max_workers = max_workers
+        self.df = self._create_data_frame()
+
+    def _create_data_frame(self):
+        """Private method that returns a dataframe with information about the dataset."""
+
+        if self.path:
+            self.img_list = glob.glob(f'{self.path}/*{self.postfix}*')
+            if not self.img_list: print('Could not find images. Check the image path')
+
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            data_info_dict = list(executor.map(self._get_data_info, self.img_list))
+
+        df = pd.DataFrame(data_info_dict)
+        
+        if df.orientation.nunique() > 1:
+            print('The volumes in this dataset have different orientations. '
+                  'Recommended to pass in the argument reorder=True when creating a MedDataset object for this dataset')
+
+        return df
+
+    def summary(self):
+        """Summary DataFrame of the dataset with example path for similar data."""
+        
+        columns = ['dim_0', 'dim_1', 'dim_2', 'voxel_0', 'voxel_1', 'voxel_2', 'orientation']
+        
+        return self.df.groupby(columns, as_index=False).agg(
+            example_path=('path', 'min'), total=('path', 'size')
+        ).sort_values('total', ascending=False)
+
+    def suggestion(self):
+        """Voxel value that appears most often in dim_0, dim_1 and dim_2, and whether the data should be reoriented."""
+        
+        resample = [self.df.voxel_0.mode()[0], self.df.voxel_1.mode()[0], self.df.voxel_2.mode()[0]]
+        return resample, self.reorder
+
+    def _get_data_info(self, fn: str):
+        """Private method to collect information about an image file."""
+        _, o, _ = med_img_reader(fn, dtype=self.dtype, reorder=self.reorder, only_tensor=False)
+
+        info_dict = {'path': fn, 'dim_0': o.shape[1], 'dim_1': o.shape[2], 'dim_2': o.shape[3],
+                     'voxel_0': round(o.spacing[0], 4), 'voxel_1': round(o.spacing[1], 4), 'voxel_2': round(o.spacing[2], 4),
+                     'orientation': f'{"".join(o.orientation)}+'}
+
+        if self.dtype is MedMask:
+            mask_labels_dict = o.count_labels()
+            mask_labels_dict = {f'voxel_count_{int(key)}': val for key, val in mask_labels_dict.items()}
+            info_dict.update(mask_labels_dict)
+
+        return info_dict
+
+    def get_largest_img_size(self, resample: list = None) -> list:
+        """Get the largest image size in the dataset."""
+        
+        dims = None
+
+        if resample is not None:
+            org_voxels = self.df[["voxel_0", "voxel_1", 'voxel_2']].values
+            org_dims = self.df[["dim_0", "dim_1", 'dim_2']].values
+
+            ratio = org_voxels/resample
+            new_dims = (org_dims * ratio).T
+            dims = [new_dims[0].max().round(), new_dims[1].max().round(), new_dims[2].max().round()]
+
+        else:
+            dims = [df.dim_0.max(), df.dim_1.max(), df.dim_2.max()]
+
+        return dims
+
+# %% ../nbs/08_dataset_info.ipynb 5
+def get_class_weights(labels: (np.array, list), class_weight: str = 'balanced') -> torch.Tensor: 
+    """Calculates and returns the class weights.
+
+    Args:
+        labels: An array or list of class labels for each instance in the dataset.
+        class_weight: Defaults to 'balanced'.
+
+    Returns:
+        A tensor of class weights.
+    """
+    
+    class_weights =  compute_class_weight(class_weight=class_weight, classes=np.unique(labels), y=labels)
+    
+    return torch.Tensor(class_weights)

fastMONAI-0.3.3/fastMONAI/external_data.py

@@ -0,0 +1,300 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/09_external_data.ipynb.
+
+# %% auto 0
+__all__ = ['MURLs', 'download_ixi_data', 'download_ixi_tiny', 'download_spine_test_data', 'download_example_spine_data',
+           'download_medmnist3d_dataset', 'download_example_endometrial_cancer_data']
+
+# %% ../nbs/09_external_data.ipynb 1
+from pathlib import Path
+from glob import glob
+from numpy import load 
+import pandas as pd
+from monai.apps import download_url, download_and_extract
+from torchio.datasets.ixi import IXITiny
+from torchio import ScalarImage
+import multiprocessing as mp
+from functools import partial
+
+# %% ../nbs/09_external_data.ipynb 3
+class MURLs():
+    """A class with external medical dataset URLs."""
+
+    IXI_DATA = 'http://biomedic.doc.ic.ac.uk/brain-development/downloads/IXI/IXI-T1.tar'
+    IXI_DEMOGRAPHIC_INFORMATION = 'http://biomedic.doc.ic.ac.uk/brain-development/downloads/IXI/IXI.xls'
+    CHENGWEN_CHU_SPINE_DATA = 'https://drive.google.com/uc?id=1rbm9-KKAexpNm2mC9FsSbfnS8VJaF3Kn&confirm=t'
+    EXAMPLE_SPINE_DATA = 'https://drive.google.com/uc?id=1Ms3Q6MYQrQUA_PKZbJ2t2NeYFQ5jloMh'
+    MEDMNIST_DICT = {'OrganMNIST3D': 'https://zenodo.org/record/6496656/files/organmnist3d.npz?download=1',	
+                     'NoduleMNIST3D': 'https://zenodo.org/record/6496656/files/nodulemnist3d.npz?download=1',
+                     'AdrenalMNIST3D': 'https://zenodo.org/record/6496656/files/adrenalmnist3d.npz?download=1',	
+                     'FractureMNIST3D': 'https://zenodo.org/record/6496656/files/fracturemnist3d.npz?download=1',
+                     'VesselMNIST3D': 'https://zenodo.org/record/6496656/files/vesselmnist3d.npz?download=1', 
+                     'SynapseMNIST3D': 'https://zenodo.org/record/6496656/files/synapsemnist3d.npz?download=1'}
+    EXAMPLE_EC_DATA = 'https://drive.google.com/uc?id=1cjOBhkdRsoX3unxHiL377R5j8ottN4An'
+
+# %% ../nbs/09_external_data.ipynb 4
+def _process_ixi_xls(xls_path: (str, Path), img_path: Path) -> pd.DataFrame:
+    """Private method to process the demographic information for the IXI dataset.
+
+    Args:
+        xls_path: File path to the xls file with the demographic information.
+        img_path: Folder path to the images.
+
+    Returns:
+        A processed dataframe with image path and demographic information.
+
+    Raises:
+        ValueError: If xls_path or img_path do not exist.
+    """
+
+    print('Preprocessing ' + str(xls_path))
+
+    df = pd.read_excel(xls_path)
+
+    duplicate_subject_ids = df[df.duplicated(['IXI_ID'], keep=False)].IXI_ID.unique()
+
+    for subject_id in duplicate_subject_ids:
+        age = df.loc[df.IXI_ID == subject_id].AGE.nunique()
+        if age != 1: df = df.loc[df.IXI_ID != subject_id]  # Remove duplicates with two different age values
+
+    df = df.drop_duplicates(subset='IXI_ID', keep='first').reset_index(drop=True)
+
+    df['subject_id'] = ['IXI' + str(subject_id).zfill(3) for subject_id in df.IXI_ID.values]
+    df = df.rename(columns={'SEX_ID (1=m, 2=f)': 'gender'})
+    df['age_at_scan'] = df.AGE.round(2)
+    df = df.replace({'gender': {1: 'M', 2: 'F'}})
+
+    img_list = list(img_path.glob('*.nii.gz'))
+    for path in img_list:
+        subject_id = path.parts[-1].split('-')[0]
+        df.loc[df.subject_id == subject_id, 't1_path'] = str(path)
+
+    df = df.dropna()
+    df = df[['t1_path', 'subject_id', 'gender', 'age_at_scan']]
+    
+    return df
+
+# %% ../nbs/09_external_data.ipynb 6
+def download_ixi_data(path: (str, Path) = '../data') -> Path:
+    """Download T1 scans and demographic information from the IXI dataset.
+    
+    Args:
+        path: Path to the directory where the data will be stored. Defaults to '../data'.
+
+    Returns:
+        The path to the stored CSV file.
+    """
+
+    path = Path(path) / 'IXI'
+    img_path = path / 'T1_images'
+
+    # Check whether image data already present in img_path:
+    is_extracted = False
+    try:
+        if len(list(img_path.iterdir())) >= 581:  # 581 imgs in the IXI dataset
+            is_extracted = True
+            print(f"Images already downloaded and extracted to {img_path}")
+    except:
+        is_extracted = False
+
+    if not is_extracted:
+        download_and_extract(url=MURLs.IXI_DATA, filepath=path / 'IXI-T1.tar', output_dir=img_path)
+        (path / 'IXI-T1.tar').unlink()
+
+    download_url(url=MURLs.IXI_DEMOGRAPHIC_INFORMATION, filepath=path / 'IXI.xls')
+
+    processed_df = _process_ixi_xls(xls_path=path / 'IXI.xls', img_path=img_path)
+    processed_df.to_csv(path / 'dataset.csv', index=False)
+
+    return path
+
+# %% ../nbs/09_external_data.ipynb 8
+def download_ixi_tiny(path: (str, Path) = '../data') -> Path:
+    """Download the tiny version of the IXI dataset provided by TorchIO.
+
+    Args:
+        path: The directory where the data will be 
+            stored. If not provided, defaults to '../data'.
+
+    Returns:
+        The path to the directory where the data is stored.
+    """
+    
+    path = Path(path) / 'IXITiny'
+    
+    IXITiny(root=str(path), download=True)
+    download_url(url=MURLs.IXI_DEMOGRAPHIC_INFORMATION, filepath=path/'IXI.xls')
+    
+    processed_df = _process_ixi_xls(xls_path=path/'IXI.xls', img_path=path/'image')
+    processed_df['labels'] = processed_df['t1_path'].str.replace('image','label')
+    
+    processed_df.to_csv(path/'dataset.csv', index=False)
+    
+    return path
+
+# %% ../nbs/09_external_data.ipynb 10
+def _create_spine_df(dir: Path) -> pd.DataFrame:
+    """Create a pandas DataFrame containing information about spinal images.
+
+    Args:
+        dir: Directory path where data (image and segmentation 
+            mask files) are stored.
+
+    Returns:
+         A DataFrame containing the paths to the image files and their 
+            corresponding mask files, the subject IDs, and a flag indicating that 
+            these are test data.
+    """
+    
+    img_list = glob(str(dir / 'img/*.nii.gz'))
+    mask_list = [str(fn).replace('img', 'seg') for fn in img_list]
+    subject_id_list = [fn.split('_')[-1].split('.')[0] for fn in mask_list]
+    
+    test_data = {
+        't2_img_path': img_list,
+        't2_mask_path': mask_list,
+        'subject_id': subject_id_list,
+        'is_test': True,
+    }
+
+    return pd.DataFrame(test_data)
+
+# %% ../nbs/09_external_data.ipynb 11
+def download_spine_test_data(path: (str, Path) = '../data') -> pd.DataFrame:
+    """Downloads T2w scans from the study 'Fully Automatic Localization and 
+    Segmentation of 3D Vertebral Bodies from CT/MR Images via a Learning-Based 
+    Method' by Chu et. al. 
+
+    Args:
+        path: Directory where the downloaded data 
+            will be stored and extracted. Defaults to '../data'.
+
+    Returns:
+        Processed dataframe containing image paths, label paths, and subject IDs.
+    """
+    
+    study = 'chengwen_chu_2015'
+    
+    download_and_extract(
+        url=MURLs.CHENGWEN_CHU_SPINE_DATA, 
+        filepath=f'{study}.zip', 
+        output_dir=path
+    )
+    Path(f'{study}.zip').unlink()
+    
+    return _create_spine_df(Path(path) / study)
+
+# %% ../nbs/09_external_data.ipynb 12
+def download_example_spine_data(path: (str, Path) = '../data') -> Path:
+    """Downloads example T2w scan and corresponding predicted mask.
+    
+    Args:
+        path: Directory where the downloaded data 
+            will be stored and extracted. Defaults to '../data'.
+
+    Returns:
+        Path to the directory where the example data has been extracted.
+    """
+    
+    study = 'example_data'
+    
+    download_and_extract(
+        url=MURLs.EXAMPLE_SPINE_DATA, 
+        filepath='example_data.zip', 
+        output_dir=path
+    )
+    Path('example_data.zip').unlink()
+    
+    return Path(path) / study
+
+# %% ../nbs/09_external_data.ipynb 14
+def _process_medmnist_img(path, idx_arr):
+    """Save tensor as NIfTI."""
+    
+    idx, arr = idx_arr
+    img = ScalarImage(tensor=arr[None, :])
+    fn = path/f'{idx}_nodule.nii.gz'
+    img.save(fn)
+    return str(fn)
+
+# %% ../nbs/09_external_data.ipynb 15
+def _df_sort_and_add_columns(df, label_list, is_val):
+    """Sort the dataframe based on img_idx and add labels and if it is validation data column."""
+    
+    df = df.sort_values(by='img_idx').reset_index(drop=True)
+    df['labels'], df['is_val'] = label_list, is_val     
+    #df = df.replace({"labels": {0:'b', 1:'m'}})
+    df = df.drop('img_idx', axis=1)
+    
+    return df 
+
+# %% ../nbs/09_external_data.ipynb 16
+def _create_nodule_df(pool, output_dir, imgs, labels, is_val=False): 
+    """Create dataframe for MedMNIST data."""
+    
+    img_path_list = pool.map(partial(_process_medmnist_img, output_dir), enumerate(imgs))
+    img_idx = [float(Path(fn).parts[-1].split('_')[0]) for fn in img_path_list]
+    
+    df = pd.DataFrame(list(zip(img_path_list, img_idx)), columns=['img_path','img_idx'])        
+    return  _df_sort_and_add_columns(df, labels, is_val)
+
+# %% ../nbs/09_external_data.ipynb 17
+def download_medmnist3d_dataset(study: str, path: (str, Path) = '../data',
+                                max_workers: int = 1):
+    """Downloads and processes a particular MedMNIST3D dataset.
+
+    Args:
+        study: MedMNIST dataset ('OrganMNIST3D', 'NoduleMNIST3D', 
+               'AdrenalMNIST3D', 'FractureMNIST3D', 'VesselMNIST3D', 'SynapseMNIST3D')
+        path: Directory to store and extract downloaded data. Defaults to '../data'.
+        max_workers: Maximum number of worker processes for data processing. 
+                     Defaults to 1.
+
+    Returns:
+        Two pandas DataFrames. The first DataFrame combines training and validation 
+        data, and the second DataFrame contains the testing data.
+    """
+    path = Path(path) / study
+    dataset_file_path = path / f'{study}.npz'
+
+    try:
+        #todo: check if dataset is downloaded
+        download_url(url=MURLs.MEDMNIST_DICT[study], filepath=dataset_file_path)
+    except:
+        raise ValueError(f"Dataset '{study}' does not exist.")
+
+    data = load(dataset_file_path)
+    keys = ['train_images', 'val_images', 'test_images']
+
+    for key in keys:
+        (path / key).mkdir(exist_ok=True)
+
+    train_imgs = data[keys[0]]
+    val_imgs = data[keys[1]]
+    test_imgs = data[keys[2]]
+
+    with mp.Pool(processes=max_workers) as pool:
+        train_df = _create_nodule_df(pool, path / keys[0], train_imgs, 
+                                     data['train_labels'])
+        val_df = _create_nodule_df(pool, path / keys[1], val_imgs, 
+                                   data['val_labels'], is_val=True)
+        test_df = _create_nodule_df(pool, path / keys[2], test_imgs, 
+                                    data['test_labels'])
+
+    train_val_df = pd.concat([train_df, val_df], ignore_index=True)
+
+    dataset_file_path.unlink()
+
+    return train_val_df, test_df
+
+# %% ../nbs/09_external_data.ipynb 19
+def download_example_endometrial_cancer_data(path: (str, Path) = '../data') -> Path:
+    study = 'ec'
+    
+    download_and_extract(
+        url=MURLs.EXAMPLE_EC_DATA, 
+        filepath='ec.zip', 
+        output_dir=path
+    )
+    Path('ec.zip').unlink()
+    
+    return Path(path) / study

{fastMONAI-0.3.1 → fastMONAI-0.3.3}/fastMONAI/utils.py

@@ -9,12 +9,8 @@ import torch
 from pathlib import Path
 
 # %% ../nbs/07_utils.ipynb 3
-def store_variables(pkl_fn:(str, Path),
-                    size:list,
-                    reorder:bool,
-                    resample:(int,list),
-                   ) -> None:
-    '''Save variable values in a pickle file.'''
+def store_variables(pkl_fn: (str, Path), size: list, reorder: bool, resample: (int, list)):
+    """Save variable values in a pickle file."""
     
     var_vals = [size, reorder, resample]
     
@@ -22,19 +18,21 @@ def store_variables(pkl_fn:(str, Path),
         pickle.dump(var_vals, f)
 
 # %% ../nbs/07_utils.ipynb 4
-def load_variables(pkl_fn # Filename of the pickle file
-                  ):
-    '''Load stored variable values from a pickle file.
+def load_variables(pkl_fn: (str, Path)):
+    """Loads stored variable values from a pickle file.
 
-    Returns: A list of variable values.
-    '''
+    Args:
+        pkl_fn: File path of the pickle file to be loaded.
 
+    Returns:
+        The deserialized value of the pickled data.
+    """
     with open(pkl_fn, 'rb') as f:
         return pickle.load(f)
 
 # %% ../nbs/07_utils.ipynb 5
 def print_colab_gpu_info(): 
-    '''Check if we have a GPU attached to the runtime.'''
+    """Check if we have a GPU attached to the runtime."""
     
     colab_gpu_msg =(f"{'#'*80}\n"
                     "Remember to attach a GPU to your Colab Runtime:"