deepliif 1.1.13__py3-none-any.whl → 1.1.14__py3-none-any.whl

deepliif/models/__init__.py

@@ -25,6 +25,8 @@ from functools import lru_cache
 from io import BytesIO
 import json
 import math
+import importlib.metadata
+import pathlib
 
 import requests
 import torch
@@ -37,7 +39,7 @@ from dask import delayed, compute
 from deepliif.util import *
 from deepliif.util.util import tensor_to_pil
 from deepliif.data import transform
-from deepliif.postprocessing import compute_final_results, compute_cell_results
+from deepliif.postprocessing import compute_final_results, compute_cell_results, to_array
 from deepliif.postprocessing import encode_cell_data_v4, decode_cell_data_v4
 from deepliif.options import Options, print_options
 
@@ -167,7 +169,7 @@ def init_nets(model_dir, eager_mode=False, opt=None, phase='test'):
         opt = get_opt(model_dir, mode=phase)
     opt.use_dp = False
     
-    if opt.model == 'DeepLIIF':
+    if opt.model in ['DeepLIIF','DeepLIIFKD']:
         net_groups = [
             ('G1', 'G52'),
             ('G2', 'G53'),
@@ -217,13 +219,14 @@ def compute_overlap(img_size, tile_size):
     return tile_size // 4
 
 
-def run_torchserve(img, model_path=None, eager_mode=False, opt=None, seg_only=False):
+def run_torchserve(img, model_path=None, nets=None, eager_mode=False, opt=None, seg_only=False, use_dask=True, output_tensor=False):
     """
     eager_mode: not used in this function; put in place to be consistent with run_dask
            so that run_wrapper() could call either this function or run_dask with
            same syntax
     opt: same as eager_mode
     seg_only: same as eager_mode
+    nets: same as eager_mode
     """
     buffer = BytesIO()
     torch.save(transform(img.resize((opt.scale_size, opt.scale_size))), buffer)
@@ -242,16 +245,28 @@ def run_torchserve(img, model_path=None, eager_mode=False, opt=None, seg_only=Fa
     return {k: tensor_to_pil(deserialize_tensor(v)) for k, v in res.json().items()}
 
 
-def run_dask(img, model_path, eager_mode=False, opt=None, seg_only=False):
-    model_dir = os.getenv('DEEPLIIF_MODEL_DIR', model_path)
-    nets = init_nets(model_dir, eager_mode, opt)
-    use_dask = True if opt.norm != 'spectral' else False
+def run_dask(img, model_path=None, nets=None, eager_mode=False, opt=None, seg_only=False, use_dask=True, output_tensor=False):
+    """
+    Provide either the model path or the networks object.
+    
+    `eager_mode` is only applicable if model_path is provided.
+    """
+    assert model_path is not None or nets is not None, 'Provide either the model path or the networks object.'
+    if nets is None:
+        model_dir = os.getenv('DEEPLIIF_MODEL_DIR', model_path)
+        nets = init_nets(model_dir, eager_mode, opt)
+    
+    if use_dask: # check if use_dask should be overwritten
+        use_dask = True if opt.norm != 'spectral' else False
     
-    if opt.input_no > 1 or opt.model == 'SDG':
-        l_ts = [transform(img_i.resize((opt.scale_size,opt.scale_size))) for img_i in img]
-        ts = torch.cat(l_ts, dim=1)
+    if isinstance(img,torch.Tensor): # if img input is already a tensor, pass
+        ts = img
     else:
-        ts = transform(img.resize((opt.scale_size, opt.scale_size)))
+        if opt.input_no > 1 or opt.model == 'SDG':
+            l_ts = [transform(img_i.resize((opt.scale_size,opt.scale_size))) for img_i in img]
+            ts = torch.cat(l_ts, dim=1)
+        else:
+            ts = transform(img.resize((opt.scale_size, opt.scale_size)))
     
 
     if use_dask:
@@ -264,13 +279,20 @@ def run_dask(img, model_path, eager_mode=False, opt=None, seg_only=False):
             with torch.no_grad():
                 return model(input.to(next(model.parameters()).device))
     
-    if opt.model == 'DeepLIIF':
+    if opt.model in ['DeepLIIF','DeepLIIFKD']:
+        #weights = {
+        #    'G51': 0.25, # IHC
+        #    'G52': 0.25, # Hema
+        #    'G53': 0.25, # DAPI
+        #    'G54': 0.00, # Lap2
+        #    'G55': 0.25, # Marker
+        #}
         weights = {
-            'G51': 0.25, # IHC
-            'G52': 0.25, # Hema
-            'G53': 0.25, # DAPI
-            'G54': 0.00, # Lap2
-            'G55': 0.25, # Marker
+            'G51': 0.5, # IHC
+            'G52': 0.0, # Hema
+            'G53': 0.0, # DAPI
+            'G54': 0.0, # Lap2
+            'G55': 0.5, # Marker
         }
 
         seg_map = {'G1': 'G52', 'G2': 'G53', 'G3': 'G54', 'G4': 'G55'}
@@ -282,19 +304,27 @@ def run_dask(img, model_path, eager_mode=False, opt=None, seg_only=False):
             lazy_gens['G4'] = forward(ts, nets['G4'])
         gens = compute(lazy_gens)[0]
         
-        lazy_segs = {v: forward(gens[k], nets[v]).to(torch.device('cpu')) for k, v in seg_map.items()}
+        lazy_segs = {v: forward(gens[k], nets[v]) for k, v in seg_map.items()}
         if not seg_only or weights['G51'] != 0:
-            lazy_segs['G51'] = forward(ts, nets['G51']).to(torch.device('cpu'))
+            lazy_segs['G51'] = forward(ts, nets['G51'])
         segs = compute(lazy_segs)[0]
-    
-        seg = torch.stack([torch.mul(segs[k], weights[k]) for k in segs.keys()]).sum(dim=0)
-    
-        if seg_only:
-            res = {'G4': tensor_to_pil(gens['G4'])} if 'G4' in gens else {}
+        
+        device = next(nets['G1'].parameters()).device # take the device of the first net and move all outputs there for seg aggregation
+        seg = torch.stack([torch.mul(segs[k].to(device), weights[k]) for k in segs.keys()]).sum(dim=0)
+        
+        if output_tensor:
+            if seg_only:
+                res = {'G4': gens['G4']} if 'G4' in gens else {}
+            else:
+                res = {**gens, **segs}
+            res['G5'] = seg
         else:
-            res = {k: tensor_to_pil(v) for k, v in gens.items()}
-            res.update({k: tensor_to_pil(v) for k, v in segs.items()})
-        res['G5'] = tensor_to_pil(seg)
+            if seg_only:
+                res = {'G4': tensor_to_pil(gens['G4'].to(torch.device('cpu')))} if 'G4' in gens else {}
+            else:
+                res = {k: tensor_to_pil(v.to(torch.device('cpu'))) for k, v in gens.items()}
+                res.update({k: tensor_to_pil(v.to(torch.device('cpu'))) for k, v in segs.items()})
+            res['G5'] = tensor_to_pil(seg.to(torch.device('cpu')))
     
         return res
     elif opt.model in ['DeepLIIFExt','SDG','CycleGAN']:
@@ -332,8 +362,8 @@ def is_empty(tile):
         return True if np.max(image_variance_rgb(tile)) < thresh else False
 
 
-def run_wrapper(tile, run_fn, model_path, eager_mode=False, opt=None, seg_only=False):
-    if opt.model == 'DeepLIIF':
+def run_wrapper(tile, run_fn, model_path=None, nets=None, eager_mode=False, opt=None, seg_only=False, use_dask=True, output_tensor=False):
+    if opt.model in ['DeepLIIF','DeepLIIFKD']:
         if is_empty(tile):
             if seg_only:
                 return {
@@ -354,31 +384,38 @@ def run_wrapper(tile, run_fn, model_path, eager_mode=False, opt=None, seg_only=F
                     'G55': Image.new(mode='RGB', size=(512, 512), color=(0, 0, 0)),
                 }
         else:
-            return run_fn(tile, model_path, eager_mode, opt, seg_only)
+            return run_fn(tile, model_path, None, eager_mode, opt, seg_only)
     elif opt.model in ['DeepLIIFExt', 'SDG']:
         if is_empty(tile):
             res = {'G_' + str(i): Image.new(mode='RGB', size=(512, 512)) for i in range(1, opt.modalities_no + 1)}
             res.update({'GS_' + str(i): Image.new(mode='RGB', size=(512, 512)) for i in range(1, opt.modalities_no + 1)})
             return res
         else:
-            return run_fn(tile, model_path, eager_mode, opt)
+            return run_fn(tile, model_path, None, eager_mode, opt)
     elif opt.model in ['CycleGAN']:
         if is_empty(tile):
             net_names = ['GB_{i+1}' for i in range(opt.modalities_no)] if opt.BtoA else [f'GA_{i+1}' for i in range(opt.modalities_no)]
             res = {net_name: Image.new(mode='RGB', size=(512, 512)) for net_name in net_names}
             return res
         else:
-            return run_fn(tile, model_path, eager_mode, opt)
+            return run_fn(tile, model_path, None, eager_mode, opt)
     else:
         raise Exception(f'run_wrapper() not implemented for model {opt.model}')
 
 
 def inference(img, tile_size, overlap_size, model_path, use_torchserve=False,
               eager_mode=False, color_dapi=False, color_marker=False, opt=None,
-              return_seg_intermediate=False, seg_only=False):
+              return_seg_intermediate=False, seg_only=False, opt_args={}):
+    """
+    opt_args: a dictionary of key and values to add/overwrite to opt
+    """
     if not opt:
         opt = get_opt(model_path)
         #print_options(opt)
+    
+    for k,v in opt_args.items():
+        setattr(opt,k,v)
+    #print_options(opt)
 
     run_fn = run_torchserve if use_torchserve else run_dask
 
@@ -393,10 +430,11 @@ def inference(img, tile_size, overlap_size, model_path, use_torchserve=False,
 
     tiler = InferenceTiler(orig, tile_size, overlap_size)
     for tile in tiler:
-        tiler.stitch(run_wrapper(tile, run_fn, model_path, eager_mode, opt, seg_only))
+        tiler.stitch(run_wrapper(tile, run_fn, model_path, None, eager_mode, opt, seg_only))
+        
     results = tiler.results()
 
-    if opt.model == 'DeepLIIF':
+    if opt.model in ['DeepLIIF','DeepLIIFKD']:
         if seg_only:
             images = {'Seg': results['G5']}
             if 'G4' in results:
@@ -445,7 +483,7 @@ def inference(img, tile_size, overlap_size, model_path, use_torchserve=False,
 
 
 def postprocess(orig, images, tile_size, model, seg_thresh=150, size_thresh='default', marker_thresh=None, size_thresh_upper=None):
-    if model == 'DeepLIIF':
+    if model in ['DeepLIIF','DeepLIIFKD']:
         resolution = '40x' if tile_size > 384 else ('20x' if tile_size > 192 else '10x')
         overlay, refined, scoring = compute_final_results(
             orig, images['Seg'], images.get('Marker'), resolution,
@@ -706,6 +744,7 @@ def infer_cells_for_wsi(filename, model_dir, tile_size, region_size=20000, versi
                 print_info(region.shape, region.dtype)
                 img = Image.fromarray((region * 255).astype(np.uint8)) if rescale else Image.fromarray(region)
                 print_info(img.size, img.mode)
+                del region
 
                 images = inference(
                     img,
@@ -719,7 +758,15 @@ def infer_cells_for_wsi(filename, model_dir, tile_size, region_size=20000, versi
                     return_seg_intermediate=False,
                     seg_only=True,
                 )
-                region_data = compute_cell_results(images['Seg'], images.get('Marker'), resolution, version=version)
+                del img
+
+                seg = to_array(images['Seg'])
+                del images['Seg']
+                marker = to_array(images['Marker'], True) if 'Marker' in images else None
+                del images
+                region_data = compute_cell_results(seg, marker, resolution, version=version)
+                del seg
+                del marker
 
                 if start_x != 0 or start_y != 0:
                     for i in range(len(region_data['cells'])):
@@ -757,4 +804,14 @@ def infer_cells_for_wsi(filename, model_dir, tile_size, region_size=20000, versi
     data['settings']['default_marker_thresh'] = round(default_marker_thresh / count_marker_thresh)
     data['settings']['default_size_thresh'] = round(default_size_thresh / count_size_thresh)
 
+    try:
+        data['deepliifVersion'] = importlib.metadata.version('deepliif')
+    except Exception as e:
+        data['deepliifVersion'] = 'unknown'
+
+    try:
+        data['modelVersion'] = pathlib.PurePath(model_dir).name
+    except Exception as e:
+        data['modelVersion'] = 'unknown'
+
     return data

deepliif/models/base_model.py

@@ -147,7 +147,7 @@ class BaseModel(ABC):
             if isinstance(name, str):
                 if not hasattr(self, name):
                     if len(name.split('_')) != 2:
-                        if self.opt.model == 'DeepLIIF':
+                        if self.opt.model in ['DeepLIIF','DeepLIIFKD']:
                             img_name = name[:-1] + '_' + name[-1]
                             visual_ret[name] = getattr(self, img_name)
                         else:

deepliif/models/networks.py

@@ -172,12 +172,14 @@ def define_G(
     norm_layer = get_norm_layer(norm_type=norm)
     use_spectral_norm = norm == 'spectral'
 
-    if netG == 'resnet_9blocks':
-        net = ResnetGenerator(input_nc, output_nc, ngf, norm_layer=norm_layer, use_dropout=use_dropout, n_blocks=9, 
-                              padding_type=padding_type, upsample=upsample, use_spectral_norm=use_spectral_norm)
-    elif netG == 'resnet_6blocks':
-        net = ResnetGenerator(input_nc, output_nc, ngf, norm_layer=norm_layer, use_dropout=use_dropout, n_blocks=6, 
+    if netG.startswith('resnet_'):
+        n_blocks = int(netG.split('_')[1].replace('blocks',''))
+        net = ResnetGenerator(input_nc, output_nc, ngf, norm_layer=norm_layer, use_dropout=use_dropout, n_blocks=n_blocks, 
                               padding_type=padding_type, upsample=upsample, use_spectral_norm=use_spectral_norm)
+    elif netG == 'unet_32':
+        net = UnetGenerator(input_nc, output_nc, 5, ngf, norm_layer=norm_layer, use_dropout=use_dropout)
+    elif netG == 'unet_64':
+        net = UnetGenerator(input_nc, output_nc, 6, ngf, norm_layer=norm_layer, use_dropout=use_dropout)
     elif netG == 'unet_128':
         net = UnetGenerator(input_nc, output_nc, 7, ngf, norm_layer=norm_layer, use_dropout=use_dropout)
     elif netG == 'unet_256':

deepliif/postprocessing.py

@@ -184,32 +184,38 @@ def mark_background(mask):
         After the function executes, the pixels will be labeled as background, positive, negative, or unknown.
     """
 
-    seeds = []
     for i in range(mask.shape[0]):
         if mask[i, 0] == LABEL_UNKNOWN:
-            seeds.append((i, 0))
+            mask[i, 0] = LABEL_BACKGROUND
         if mask[i, mask.shape[1]-1] == LABEL_UNKNOWN:
-            seeds.append((i, mask.shape[1]-1))
+            mask[i, mask.shape[1]-1] = LABEL_BACKGROUND
     for j in range(mask.shape[1]):
         if mask[0, j] == LABEL_UNKNOWN:
-            seeds.append((0, j))
+            mask[0, j] = LABEL_BACKGROUND
         if mask[mask.shape[0]-1, j] == LABEL_UNKNOWN:
-            seeds.append((mask.shape[0]-1, j))
-
-    neighbors = [(-1, 0), (1, 0), (0, -1), (0, 1)]
-
-    while len(seeds) > 0:
-        seed = seeds.pop()
-        if mask[seed] == LABEL_UNKNOWN:
-            mask[seed] = LABEL_BACKGROUND
-            for n in neighbors:
-                idx = (seed[0] + n[0], seed[1] + n[1])
-                if in_bounds(mask, idx) and mask[idx] == LABEL_UNKNOWN:
-                    seeds.append(idx)
+            mask[mask.shape[0]-1, j] = LABEL_BACKGROUND
+
+    count = 1
+    while count > 0:
+        count = 0
+        for i in range(mask.shape[0]):
+            for j in range(mask.shape[1]):
+                if mask[i, j] == LABEL_UNKNOWN:
+                    if (mask[i-1, j] == LABEL_BACKGROUND or mask[i+1, j] == LABEL_BACKGROUND or
+                            mask[i, j-1] == LABEL_BACKGROUND or mask[i, j+1] == LABEL_BACKGROUND):
+                        mask[i, j] = LABEL_BACKGROUND
+                        count += 1
+        if count > 0:
+            for i in range(mask.shape[0]-1, -1, -1):
+                for j in range(mask.shape[1]-1, -1, -1):
+                    if mask[i, j] == LABEL_UNKNOWN:
+                        if (mask[i-1, j] == LABEL_BACKGROUND or mask[i+1, j] == LABEL_BACKGROUND or
+                                mask[i, j-1] == LABEL_BACKGROUND or mask[i, j+1] == LABEL_BACKGROUND):
+                            mask[i, j] = LABEL_BACKGROUND
 
 
 @jit(nopython=True)
-def compute_cell_mapping(mask, marker, noise_thresh):
+def compute_cell_mapping(mask, marker, noise_thresh, large_noise_thresh):
     """
     Compute the mapping from mask to positive and negative cells.
 
@@ -264,7 +270,7 @@ def compute_cell_mapping(mask, marker, noise_thresh):
                             center_x += idx[1]
                             count += 1
 
-                if count > noise_thresh:
+                if count > noise_thresh and (large_noise_thresh is None or count < large_noise_thresh):
                     center_y = int(round(center_y / count))
                     center_x = int(round(center_x / count))
                     positive = True if count_positive >= count_negative else False
@@ -273,7 +279,7 @@ def compute_cell_mapping(mask, marker, noise_thresh):
     return cells
 
 
-def get_cells_info(seg, marker, resolution, noise_thresh, seg_thresh):
+def get_cells_info(seg, marker, resolution, noise_thresh, seg_thresh, large_noise_thresh):
     """
     Find all cells in the segmentation image that are larger than the noise threshold.
 
@@ -289,6 +295,8 @@ def get_cells_info(seg, marker, resolution, noise_thresh, seg_thresh):
         Threshold for tiny noise to ignore (include only cells larger than this value).
     seg_thresh : int
         Threshold to use in determining if a pixel should be labeled as positive/negative.
+    large_noise_thresh : int | None
+        Threshold for large noise to ignore (include only cells smaller than this value).
 
     Returns
     -------
@@ -303,9 +311,10 @@ def get_cells_info(seg, marker, resolution, noise_thresh, seg_thresh):
     seg = to_array(seg)
     if marker is not None:
         marker = to_array(marker, True)
+
     mask = create_posneg_mask(seg, seg_thresh)
     mark_background(mask)
-    cellsinfo = compute_cell_mapping(mask, marker, noise_thresh)
+    cellsinfo = compute_cell_mapping(mask, marker, noise_thresh, large_noise_thresh)
 
     defaults = {}
     sizes = np.zeros(len(cellsinfo), dtype=np.int64)
@@ -1040,9 +1049,21 @@ def fill_cells(mask):
                     mask[y, x] = LABEL_NEGATIVE
 
 
+def calculate_large_noise_thresh(large_noise_thresh, resolution):
+    if large_noise_thresh != 'default':
+        return large_noise_thresh
+    if resolution == '10x':
+        return 250
+    elif resolution == '20x':
+        return 1000
+    else: # 40x
+        return 4000
+
+
 def compute_cell_results(seg, marker, resolution, version=3,
                          seg_thresh=DEFAULT_SEG_THRESH,
-                         noise_thresh=DEFAULT_NOISE_THRESH):
+                         noise_thresh=DEFAULT_NOISE_THRESH,
+                         large_noise_thresh='default'):
     """
     Perform postprocessing to compute individual cell results.
 
@@ -1060,6 +1081,9 @@ def compute_cell_results(seg, marker, resolution, version=3,
         Threshold to use in determining if a pixel should be labeled as positive/negative.
     noise_thresh : int
         Threshold for tiny noise to ignore (include only cells larger than this value).
+    large_noise_thresh : int | string | None
+        Threshold for large noise to ignore (include only cells smaller than this value).
+        Valid arguments can be an integer value, the string value 'default', or None.
 
     Returns
     -------
@@ -1071,7 +1095,8 @@ def compute_cell_results(seg, marker, resolution, version=3,
         warnings.warn('Invalid cell data version provided, defaulting to version 3.')
         version = 3
 
-    mask, cellsinfo, defaults = get_cells_info(seg, marker, resolution, noise_thresh, seg_thresh)
+    large_noise_thresh = calculate_large_noise_thresh(large_noise_thresh, resolution)
+    mask, cellsinfo, defaults = get_cells_info(seg, marker, resolution, noise_thresh, seg_thresh, large_noise_thresh)
 
     cells = []
     for cell in cellsinfo:
@@ -1094,6 +1119,7 @@ def compute_cell_results(seg, marker, resolution, version=3,
             'default_marker_thresh': defaults['marker_thresh'] if 'marker_thresh' in defaults else None,
             'default_size_thresh': defaults['size_thresh'],
             'noise_thresh': noise_thresh,
+            'large_noise_thresh': large_noise_thresh,
             'seg_thresh': seg_thresh,
         },
         'dataVersion': version,
@@ -1107,7 +1133,8 @@ def compute_final_results(orig, seg, marker, resolution,
                           marker_thresh=None,
                           size_thresh_upper=None,
                           seg_thresh=DEFAULT_SEG_THRESH,
-                          noise_thresh=DEFAULT_NOISE_THRESH):
+                          noise_thresh=DEFAULT_NOISE_THRESH,
+                          large_noise_thresh='default'):
     """
     Perform postprocessing to compute final count and image results.
 
@@ -1131,6 +1158,9 @@ def compute_final_results(orig, seg, marker, resolution,
         Threshold to use in determining if a pixel should be labeled as positive/negative.
     noise_thresh : int
         Threshold for tiny noise to ignore (include only cells larger than this value).
+    large_noise_thresh : int | string | None
+        Threshold for large noise to ignore (include only cells smaller than this value).
+        Valid arguments can be an integer value, the string value 'default', or None.
 
     Returns
     -------
@@ -1142,7 +1172,8 @@ def compute_final_results(orig, seg, marker, resolution,
         Dictionary with scoring and settings information.
     """
 
-    mask, cellsinfo, defaults = get_cells_info(seg, marker, resolution, noise_thresh, seg_thresh)
+    large_noise_thresh = calculate_large_noise_thresh(large_noise_thresh, resolution)
+    mask, cellsinfo, defaults = get_cells_info(seg, marker, resolution, noise_thresh, seg_thresh, large_noise_thresh)
 
     if size_thresh is None:
         size_thresh = 0

deepliif/util/checks.py

@@ -0,0 +1,17 @@
+
+
+def check_weights(model, modalities_no, seg_weights, loss_weights_g, loss_weights_d):
+    assert sum(seg_weights) == 1, 'seg weights should add up to 1'
+    assert sum(loss_weights_g) == 1, 'loss weights g should add up to 1'
+    assert sum(loss_weights_d) == 1, 'loss weights d should add up to 1'
+    
+    if model in ['DeepLIIF','DeepLIIFKD']:
+        # +1 because input becomes an additional modality used in generating the final segmentation
+        assert len(seg_weights) == modalities_no+1, 'seg weights should have the same number of elements as number of modalities to be generated'
+        assert len(loss_weights_g) == modalities_no+1, 'loss weights g should have the same number of elements as number of modalities to be generated'
+        assert len(loss_weights_d) == modalities_no+1, 'loss weights d should have the same number of elements as number of modalities to be generated'
+
+    else:
+        assert len(seg_weights) == modalities_no, 'seg weights should have the same number of elements as number of modalities to be generated'
+        assert len(loss_weights_g) == modalities_no, 'loss weights g should have the same number of elements as number of modalities to be generated'
+        assert len(loss_weights_d) == modalities_no, 'loss weights d should have the same number of elements as number of modalities to be generated'

deepliif/util/util.py

@@ -163,3 +163,45 @@ def check_multi_scale(img1, img2):
             if max_ssim[1] < image_ssim:
                 max_ssim = (tile_size, image_ssim)
     return max_ssim[0]
+
+
+import subprocess
+import os
+from threading import Thread , Timer
+import sched, time
+
+# modified from https://stackoverflow.com/questions/67707828/how-to-get-every-seconds-gpu-usage-in-python
+def get_gpu_memory(gpu_id=0):
+    """
+    Currently collects gpu memory info for a given gpu id.
+    """
+    output_to_list = lambda x: x.decode('ascii').split('\n')[:-1]
+    ACCEPTABLE_AVAILABLE_MEMORY = 1024
+    COMMAND = "nvidia-smi --query-gpu=memory.used --format=csv"
+    try:
+        memory_use_info = output_to_list(subprocess.check_output(COMMAND.split(),stderr=subprocess.STDOUT))[1:]
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError("command '{}' return with error (code {}): {}".format(e.cmd, e.returncode, e.output))
+    memory_use_values = [int(x.split()[0]) for i, x in enumerate(memory_use_info)]
+    
+    #assert len(memory_use_values)==1, f"get_gpu_memory::memory_use_values should have only 1 value, now has {len(memory_use_values)} (memory_use_values)"
+    return memory_use_values[gpu_id]
+
+class HardwareStatus():
+    def __init__(self):
+        self.gpu_mem = []
+        self.timer = None
+    
+    def get_status_every_sec(self, gpu_id=0):
+        """
+            This function calls itself every 1 sec and appends the gpu_memory.
+        """
+        self.timer = Timer(1.0, self.get_status_every_sec)
+        self.timer.start()
+        self.gpu_mem.append(get_gpu_memory(gpu_id))
+        # print('self.gpu_mem',self.gpu_mem)
+    
+    def stop_timer(self):
+        self.timer.cancel()
+
+

{deepliif-1.1.13.dist-info → deepliif-1.1.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepliif
-Version: 1.1.13
+Version: 1.1.14
 Summary: DeepLIIF: Deep-Learning Inferred Multiplex Immunofluorescence for Immunohistochemical Image Quantification
 Home-page: https://github.com/nadeemlab/DeepLIIF
 Author: Parmida93
@@ -64,7 +64,7 @@ segmentation.*
 
 © This code is made available for non-commercial academic purposes.
 
-![Version](https://img.shields.io/static/v1?label=latest&message=v1.1.13&color=darkgreen)
+![Version](https://img.shields.io/static/v1?label=latest&message=v1.1.14&color=darkgreen)
 [![Total Downloads](https://static.pepy.tech/personalized-badge/deepliif?period=total&units=international_system&left_color=grey&right_color=blue&left_text=total%20downloads)](https://pepy.tech/project/deepliif?&left_text=totalusers)
 
 ![overview_image](./images/overview.png)*Overview of DeepLIIF pipeline and sample input IHCs (different 

{deepliif-1.1.13.dist-info → deepliif-1.1.14.dist-info}/RECORD

@@ -1,10 +1,10 @@
-cli.py,sha256=IQIO_V9ubmeCOAniW9A5c8r9ETs7ehz4eJp_hrpuKo8,59625
+cli.py,sha256=luwzcSrRZMePfJ-h4Hgz2X7lYC70TUVxGfEo3LyPJgQ,58938
 deepliif/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deepliif/postprocessing.py,sha256=naq4Lt7WHg6wfOhksTASiCmZAx2P_wZSqozCkKvXNV0,40686
+deepliif/postprocessing.py,sha256=QkeyTpR5zMvsv5mj59hRK7HXpIb2fZ_81ezfMSGAhTA,42610
 deepliif/postprocessing__OLD__DELETE.py,sha256=cM-cYVidY691Sjb1-B8a1jkLq5UR_hTCbuKzuF4765o,17589
 deepliif/train.py,sha256=-ZORL5vQrD0_Jq2Adgr3w8vJ7L1QcAgNTqMnBgtixgk,15757
 deepliif/data/__init__.py,sha256=IfqVFnFSPQJZnORdRq4sNkJiylr1TaKNmhvWP_aLHdg,5492
-deepliif/data/aligned_dataset.py,sha256=Tuvll1dpnNAgwReeZ6NleKLQP__yhKxZRWcvb3IOSGY,5145
+deepliif/data/aligned_dataset.py,sha256=CkKXj94ANSi8RdhpRQjVETFYlRMER2XErIf-87BStTE,5175
 deepliif/data/base_dataset.py,sha256=bQlxfY7bGSE9WPj31ZHkCxv5CAEJovjakGDCcK-aYdc,5564
 deepliif/data/colorization_dataset.py,sha256=uDYWciSxwqZkStQ_Vte27D9x5FNhv6eR9wSPn39K3RY,2808
 deepliif/data/image_folder.py,sha256=eesP9vn__YQ-dw1KJG9J-yVUHMmJjLcIEQI552Iv2vE,2006
@@ -13,30 +13,33 @@ deepliif/data/template_dataset.py,sha256=PCDBnFRzRKReaeWgKUZmW0LrzRByI9adrKDJ6SN
 deepliif/data/unaligned_dataset.py,sha256=D69SxV087jKTd990UQIR4F3TahJHiSiw8i9Uz_xybt0,4697
 deepliif/models/CycleGAN_model.py,sha256=WDEa-Zgz57mVc9HbcVDXL5vfHvUDWdWXNLyz8ReH3rg,15196
 deepliif/models/DeepLIIFExt_model.py,sha256=HZaX9Z2ue0HQCFFN3guLkBcByCP70i8JvmPY02oOMyU,15022
+deepliif/models/DeepLIIFKD_model.py,sha256=edq9fxrDspGivuFlAYZp9B0Opp3BRIosA9e1TI_gxpc,27152
 deepliif/models/DeepLIIF_model.py,sha256=6vmsXcBcoALrhJLa7XGhDmLamO_WCzTDYEyVUBE482o,23857
 deepliif/models/SDG_model.py,sha256=3opz7uEyhvVJ8fF4_Jw4ho1MBcc9OVye-ByZD_KF2j0,10142
 deepliif/models/__init__ - different weighted.py,sha256=Oe6ichU-Qia2mODGUtQTh1OBZZnv5N-93AzOfzQiHlw,32227
 deepliif/models/__init__ - run_dask_multi dev.py,sha256=vt8X8qeiJr2aPhFi6muZEJLUSsr8XChfI45NSwL8Rfg,39449
 deepliif/models/__init__ - time gens.py,sha256=mRUtxNaGDZuhlQtKdA-OvGWTQwl7z2yMWc-9l0QrgaY,32922
 deepliif/models/__init__ - timings.py,sha256=S_wFImwxzGKx8STqbpcYCPOlbb_84WLMRDSnaWC8qFg,31750
-deepliif/models/__init__.py,sha256=EZkZu28f5ju_YiEz4yAMHQ5GAzl1-Mi6AK4kfWe20UA,31934
+"deepliif/models/__init__ - weights, empty, zarr, tile count.py",sha256=JsU9ui0Kv8AzlP3_1LeiNrQLHg9X_3r8WwYy3W4JgfA,33315
+deepliif/models/__init__.py,sha256=sNIj6fr0HRfC2kqQ4MtwyKfHDi1sf-cdmi6UgvK4lNQ,34197
 deepliif/models/att_unet.py,sha256=tqaFMNbGQUjXObOG309P76c7sIPxEvFR38EyuyHY40o,7116
-deepliif/models/base_model.py,sha256=ezWkmbuuNLGDMjyXe3VzJroj7QR1h0M9ByouzpfCrQg,16843
-deepliif/models/networks.py,sha256=Ijeb7nGf-YFgc_sBR-sIsk--0rTeiUqKZd01k4DMsuM,36614
+deepliif/models/base_model.py,sha256=ZQBI-wVfDdu296HzB_YzQraE9oUwfyRlAolNlrMi-4g,16858
+deepliif/models/networks.py,sha256=SclYeZ78U9ZSOhNrky764ZXB6muIqnHa6K0h_LDSCi0,36690
 deepliif/options/__init__.py,sha256=p2IWckf3-K-wclDWfSq5ZmynKk2lNov2Tn7WPYIO11A,8329
 deepliif/options/base_options.py,sha256=m5UXY8MvjNcDisUWuiP228yoT27SsCh1bXS_Td6SwTc,9852
 deepliif/options/processing_options.py,sha256=OnNT-ytoTQzetFiMEKrWvrsrhZlupRK4smcnIk0MbqY,2947
 deepliif/options/test_options.py,sha256=4ZbQC5U-nTbUz8jvdDIbse5TK_mjw4D5yNjpVevWD5M,1114
 deepliif/options/train_options.py,sha256=5eA_oxpRj2-HiuMMvC5-HLapxNFG_JXOQ3K132JjpR8,3580
 deepliif/util/__init__.py,sha256=_b7-t5Z54CJJIy-moeKPPLFHg5BRCKgWo5V18WqRZVo,29146
+deepliif/util/checks.py,sha256=xQirKbZxZErsAXc27M5miQUUyxptoIEJSDaUKv1nY7c,1371
 deepliif/util/get_data.py,sha256=HaRoQYb2u0LUgLT7ES-w35AmJ4BrlBEJWU4Cok29pxI,3749
 deepliif/util/html.py,sha256=RNAONZ4opP-bViahgmpSbHwOc6jXKQRnWRAVIaeIvac,3309
 deepliif/util/image_pool.py,sha256=M89Hc7DblRWroNP71S9mAdRn7h3DrhPFPjqFxxZYSgw,2280
-deepliif/util/util.py,sha256=9MNgqthJZYjl5-TJm5-sjWvMfPBz8F4P5K0RHXRQhfY,5241
+deepliif/util/util.py,sha256=WV2a1Rt-McmZm3BKW7TqC2oAKkvxWhZvjofGSfY6y7s,6810
 deepliif/util/visualizer.py,sha256=6E1sPbXdgLFB9mnPwtfEjm9O40viG4dfv5MyTpOQQpo,20210
-deepliif-1.1.13.dist-info/LICENSE.md,sha256=HlZw_UPS6EtJimJ_Ci7xKh-S5Iubs0Z8y8E6EZ3ZNyE,956
-deepliif-1.1.13.dist-info/METADATA,sha256=Ff0QjUBwpZGJcU1YgHfaixVAW6IYyHjV0FUi7QiGaRo,35195
-deepliif-1.1.13.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-deepliif-1.1.13.dist-info/entry_points.txt,sha256=f70-10j2q68o_rDlsE3hspnv4ejlDnXwwGZ9JJ-3yF4,37
-deepliif-1.1.13.dist-info/top_level.txt,sha256=vLDK5YKmDz08E7PywuvEjAo7dM5rnIpsjR4c0ubQCnc,13
-deepliif-1.1.13.dist-info/RECORD,,
+deepliif-1.1.14.dist-info/LICENSE.md,sha256=HlZw_UPS6EtJimJ_Ci7xKh-S5Iubs0Z8y8E6EZ3ZNyE,956
+deepliif-1.1.14.dist-info/METADATA,sha256=k4sMVqcfZ0B26XhwrueC903-Om3c5v1I99ynb873vEg,35195
+deepliif-1.1.14.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+deepliif-1.1.14.dist-info/entry_points.txt,sha256=f70-10j2q68o_rDlsE3hspnv4ejlDnXwwGZ9JJ-3yF4,37
+deepliif-1.1.14.dist-info/top_level.txt,sha256=vLDK5YKmDz08E7PywuvEjAo7dM5rnIpsjR4c0ubQCnc,13
+deepliif-1.1.14.dist-info/RECORD,,