deepliif 1.1.12__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
@@ -33,12 +35,11 @@ Image.MAX_IMAGE_PIXELS = None
 
 import numpy as np
 from dask import delayed, compute
-import openslide
 
 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
 
@@ -168,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'),
@@ -218,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)
@@ -243,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 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 use_dask: # check if use_dask should be overwritten
+        use_dask = True if opt.norm != 'spectral' else False
+    
+    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:
@@ -265,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'}
@@ -283,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']:
@@ -333,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 {
@@ -355,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
 
@@ -394,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:
@@ -446,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,
@@ -592,10 +629,13 @@ def infer_results_for_wsi(input_dir, filename, output_dir, model_dir, tile_size,
 
 def get_wsi_resolution(filename):
     """
-    Use OpenSlide to get the resolution (magnification) of the slide
-    and the corresponding tile size to use by default for DeepLIIF.
+    Try to get the resolution (magnification) of the slide and
+    the corresponding tile size to use by default for DeepLIIF.
     If it cannot be found, return (None, None) instead.
 
+    Note: This will start the javabridge VM, but not kill it.
+          It must be killed elsewhere.
+
     Parameters
     ----------
     filename : str
@@ -604,13 +644,42 @@ def get_wsi_resolution(filename):
     Returns
     -------
     str :
-        Magnification (objective power) as found by OpenSlide.
+        Magnification (objective power) from image metadata.
     int :
         Corresponding tile size for DeepLIIF.
     """
+
+    # make sure javabridge is already set up from with call to get_information()
+    size_x, size_y, size_z, size_c, size_t, pixel_type = get_information(filename)
+
+    mag = None
+    metadata = bioformats.get_omexml_metadata(filename)
+    try:
+        omexml = bioformats.OMEXML(metadata)
+        mag = omexml.instrument().Objective.NominalMagnification
+    except Exception as e:
+        fields = ['AppMag', 'NominalMagnification']
+        try:
+            for field in fields:
+                idx = metadata.find(field)
+                if idx >= 0:
+                    for i in range(idx, len(metadata)):
+                        if metadata[i].isdigit() or metadata[i] == '.':
+                            break
+                    for j in range(i, len(metadata)):
+                        if not metadata[j].isdigit() and metadata[j] != '.':
+                            break
+                    if i == j:
+                        continue
+                    mag = metadata[i:j]
+                    break
+        except Exception as e:
+            pass
+
+    if mag is None:
+        return None, None
+
     try:
-        image = openslide.OpenSlide(filename)
-        mag = image.properties.get(openslide.PROPERTY_NAME_OBJECTIVE_POWER)
         tile_size = round((float(mag) / 40) * 512)
         return mag, tile_size
     except Exception as e:
@@ -675,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,
@@ -688,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'])):
@@ -726,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/__init__.py

@@ -437,7 +437,7 @@ def get_information(filename):
                                                          omexml.image().Pixels.SizeC, \
                                                          omexml.image().Pixels.SizeT, \
                                                          omexml.image().Pixels.PixelType
-    print('SizeX:', size_x, ' SizeY:', size_y, ' SizeZ:', size_z, ' SizeC:', size_c, ' SizeT:', size_t, ' PixelType:', pixel_type)
+    #print('SizeX:', size_x, ' SizeY:', size_y, ' SizeZ:', size_z, ' SizeC:', size_c, ' SizeT:', size_t, ' PixelType:', pixel_type)
     return size_x, size_y, size_z, size_c, size_t, pixel_type
 
 

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.12.dist-info → deepliif-1.1.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepliif
-Version: 1.1.12
+Version: 1.1.14
 Summary: DeepLIIF: Deep-Learning Inferred Multiplex Immunofluorescence for Immunohistochemical Image Quantification
 Home-page: https://github.com/nadeemlab/DeepLIIF
 Author: Parmida93
@@ -9,7 +9,8 @@ Keywords: DeepLIIF,IHC,Segmentation,Classification
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: opencv-python (==4.8.1.78)
-Requires-Dist: torchvision (==0.10.0)
+Requires-Dist: torch (==1.13.1)
+Requires-Dist: torchvision (==0.14.1)
 Requires-Dist: scikit-image (==0.18.3)
 Requires-Dist: dominate (==2.6.0)
 Requires-Dist: numba (==0.57.1)
@@ -18,8 +19,6 @@ Requires-Dist: requests (==2.32.2)
 Requires-Dist: dask (==2021.11.2)
 Requires-Dist: visdom (>=0.1.8.3)
 Requires-Dist: python-bioformats (>=4.0.6)
-Requires-Dist: openslide-bin (==4.0.0.6)
-Requires-Dist: openslide-python (==1.4.1)
 
 
 <!-- PROJECT LOGO -->
@@ -65,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.12&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