deepliif 1.1.8__py3-none-any.whl → 1.1.10__py3-none-any.whl

cli.py

@@ -14,7 +14,7 @@ from deepliif.models import init_nets, infer_modalities, infer_results_for_wsi,
 from deepliif.util import allowed_file, Visualizer, get_information, test_diff_original_serialized, disable_batchnorm_tracking_stats
 from deepliif.util.util import mkdirs, check_multi_scale
 # from deepliif.util import infer_results_for_wsi
-from deepliif.options import Options
+from deepliif.options import Options, print_options
 
 import torch.distributed as dist
 
@@ -59,29 +59,6 @@ def set_seed(seed=0,rank=None):
 def ensure_exists(d):
     if not os.path.exists(d):
         os.makedirs(d)
-
-def print_options(opt):
-    """Print and save options
-
-    It will print both current options and default values(if different).
-    It will save options into a text file / [checkpoints_dir] / opt.txt
-    """
-    message = ''
-    message += '----------------- Options ---------------\n'
-    for k, v in sorted(vars(opt).items()):
-        comment = ''
-        message += '{:>25}: {:<30}{}\n'.format(str(k), str(v), comment)
-    message += '----------------- End -------------------'
-    print(message)
-
-    # save to the disk
-    if opt.phase == 'train':
-        expr_dir = os.path.join(opt.checkpoints_dir, opt.name)
-        mkdirs(expr_dir)
-        file_name = os.path.join(expr_dir, '{}_opt.txt'.format(opt.phase))
-        with open(file_name, 'wt') as opt_file:
-            opt_file.write(message)
-            opt_file.write('\n')
         
         
 @click.group()
@@ -212,6 +189,18 @@ def train(dataroot, name, gpu_ids, checkpoints_dir, input_nc, output_nc, ngf, nd
     plot, and save models.The script supports continue/resume training.
     Use '--continue_train' to resume your previous training.
     """
+    assert model in ['DeepLIIF','DeepLIIFExt','SDG'], f'model class {model} is not implemented'
+    if model == 'DeepLIIF':
+        seg_no = 1
+    elif model == 'DeepLIIFExt':
+        if seg_gen:
+            seg_no = modalities_no
+        else:
+            seg_no = 0
+    else: # SDG
+        seg_no = 0
+        seg_gen = False
+    
     d_params = locals()
 
     if gpu_ids and gpu_ids[0] == -1:
@@ -241,11 +230,26 @@ def train(dataroot, name, gpu_ids, checkpoints_dir, input_nc, output_nc, ngf, nd
         d_params['padding'] = 'zero'
         print('padding type is forced to zero padding, because neither refection pad2d or replication pad2d has a deterministic implementation')
 
+    # infer number of input images
+    dir_data_train = dataroot + '/train'
+    fns = os.listdir(dir_data_train)
+    fns = [x for x in fns if x.endswith('.png')]
+    img = Image.open(f"{dir_data_train}/{fns[0]}")
+    
+    num_img = img.size[0] / img.size[1]
+    assert int(num_img) == num_img, f'img size {img.size[0]} / {img.size[1]} = {num_img} is not an integer'
+    num_img = int(num_img)
+    
+    input_no = num_img - modalities_no - seg_no
+    assert input_no > 0, f'inferred number of input images is {input_no}; should be greater than 0'
+    d_params['input_no'] = input_no
+    d_params['scale_size'] = img.size[1]
+
     # create a dataset given dataset_mode and other options
     # dataset = AlignedDataset(opt)
 
     opt = Options(d_params=d_params)
-    print_options(opt)
+    print_options(opt, save=True)
     
     dataset = create_dataset(opt)
     # get the number of images in the dataset.
@@ -468,28 +472,30 @@ def trainlaunch(**kwargs):
 
 
 @cli.command()
-@click.option('--models-dir', default='./model-server/DeepLIIF_Latest_Model', help='reads models from here')
+@click.option('--model-dir', default='./model-server/DeepLIIF_Latest_Model', help='reads models from here')
 @click.option('--output-dir', help='saves results here.')
-@click.option('--tile-size', type=int, default=None, help='tile size')
-@click.option('--device', default='cpu', type=str, help='device to load model, either cpu or gpu')
+#@click.option('--tile-size', type=int, default=None, help='tile size')
+@click.option('--device', default='cpu', type=str, help='device to load model for the similarity test, either cpu or gpu')
 @click.option('--verbose', default=0, type=int,help='saves results here.')
-def serialize(models_dir, output_dir, tile_size, device, verbose):
+def serialize(model_dir, output_dir, device, verbose):
     """Serialize DeepLIIF models using Torchscript
     """
-    if tile_size is None:
-        tile_size = 512
-    output_dir = output_dir or models_dir
+    #if tile_size is None:
+    #    tile_size = 512
+    output_dir = output_dir or model_dir
     ensure_exists(output_dir)
     
     # copy train_opt.txt to the target location
     import shutil
-    if models_dir != output_dir:
-        shutil.copy(f'{models_dir}/train_opt.txt',f'{output_dir}/train_opt.txt')
+    if model_dir != output_dir:
+        shutil.copy(f'{model_dir}/train_opt.txt',f'{output_dir}/train_opt.txt')
     
-    sample = transform(Image.new('RGB', (tile_size, tile_size)))
+    opt = Options(path_file=os.path.join(model_dir,'train_opt.txt'), mode='test')
+    sample = transform(Image.new('RGB', (opt.scale_size, opt.scale_size)))
+    sample = torch.cat([sample]*opt.input_no, 1)
     
     with click.progressbar(
-            init_nets(models_dir, eager_mode=True, phase='test').items(),
+            init_nets(model_dir, eager_mode=True, phase='test').items(),
             label='Tracing nets',
             item_show_func=lambda n: n[0] if n else n
     ) as bar:
@@ -508,7 +514,7 @@ def serialize(models_dir, output_dir, tile_size, device, verbose):
     
     # test: whether the original and the serialized model produces highly similar predictions
     print('testing similarity between prediction from original vs serialized models...')
-    models_original = init_nets(models_dir,eager_mode=True,phase='test')
+    models_original = init_nets(model_dir,eager_mode=True,phase='test')
     models_serialized = init_nets(output_dir,eager_mode=False,phase='test')
     if device == 'gpu':
         sample = sample.cuda()
@@ -590,11 +596,12 @@ def test(input_dir, output_dir, tile_size, model_dir, gpu_ids, region_size, eage
                         filename.replace('.' + filename.split('.')[-1], f'_{name}.png')
                     ))
 
-                with open(os.path.join(
-                        output_dir,
-                        filename.replace('.' + filename.split('.')[-1], f'.json')
-                ), 'w') as f:
-                    json.dump(scoring, f, indent=2)
+                if scoring is not None:
+                    with open(os.path.join(
+                            output_dir,
+                            filename.replace('.' + filename.split('.')[-1], f'.json')
+                    ), 'w') as f:
+                        json.dump(scoring, f, indent=2)
 
 @cli.command()
 @click.option('--input-dir', type=str, required=True, help='Path to input images')

deepliif/data/aligned_dataset.py

@@ -26,6 +26,8 @@ class AlignedDataset(BaseDataset):
         self.output_nc = opt.input_nc if opt.direction == 'BtoA' else opt.output_nc
         self.no_flip = opt.no_flip
         self.modalities_no = opt.modalities_no
+        self.seg_no = opt.seg_no
+        self.input_no = opt.input_no
         self.seg_gen = opt.seg_gen
         self.load_size = opt.load_size
         self.crop_size = opt.crop_size
@@ -52,6 +54,8 @@ class AlignedDataset(BaseDataset):
             num_img = self.modalities_no + 1 + 1 # +1 for segmentation channel, +1 for input image
         elif self.model == 'DeepLIIFExt':
             num_img = self.modalities_no * 2 + 1 if self.seg_gen else self.modalities_no + 1 # +1 for segmentation channel   
+        elif self.model == 'SDG':
+            num_img = self.modalities_no + self.seg_no + self.input_no
         else:
             raise Exception(f'model class {self.model} does not have corresponding implementation in deepliif/data/aligned_dataset.py')
         w2 = int(w / num_img)
@@ -85,6 +89,19 @@ class AlignedDataset(BaseDataset):
                     BS_Array.append(BS)
 
             return {'A': A, 'B': B_Array, 'BS': BS_Array,'A_paths': AB_path, 'B_paths': AB_path}
+        elif self.model == 'SDG':
+            A_Array = []
+            for i in range(self.input_no):
+                A = AB.crop((w2 * i, 0, w2 * (i+1), h))
+                A = A_transform(A)
+                A_Array.append(A)
+            
+            for i in range(self.input_no, self.input_no + self.modalities_no + 1):
+                B = AB.crop((w2 * i, 0, w2 * (i + 1), h))
+                B = B_transform(B)
+                B_Array.append(B)
+            
+            return {'A': A_Array, 'B': B_Array, 'A_paths': AB_path, 'B_paths': AB_path}
         else:
             raise Exception(f'model class {self.model} does not have corresponding implementation in deepliif/data/aligned_dataset.py')
         

deepliif/models/SDG_model.py

@@ -0,0 +1,189 @@
+import torch
+from .base_model import BaseModel
+from . import networks
+
+
+class SDGModel(BaseModel):
+    """ This class implements the Synthetic Data Generation model (based on DeepLIIFExt), for learning a mapping from input images to modalities given paired data."""
+
+    def __init__(self, opt):
+        """Initialize the DeepLIIF class.
+
+        Parameters:
+            opt (Option class)-- stores all the experiment flags; needs to be a subclass of BaseOptions
+        """
+        BaseModel.__init__(self, opt)
+
+        self.mod_gen_no = self.opt.modalities_no
+
+        # weights of the modalities in generating segmentation mask
+        self.seg_weights = [0, 0, 0]
+        if opt.seg_gen:
+            self.seg_weights = [0.3] * self.mod_gen_no
+            self.seg_weights[1] = 0.4
+
+        # self.seg_weights = opt.seg_weights
+        # assert len(self.seg_weights) == self.seg_gen_no, 'The number of the segmentation weights (seg_weights) is not equal to the number of target images (modalities_no)!'
+        # print(self.seg_weights)
+        # loss weights in calculating the final loss
+        self.loss_G_weights = [1 / self.mod_gen_no] * self.mod_gen_no
+        self.loss_GS_weights = [1 / self.mod_gen_no] * self.mod_gen_no
+
+        self.loss_D_weights = [1 / self.mod_gen_no] * self.mod_gen_no
+        self.loss_DS_weights = [1 / self.mod_gen_no] * self.mod_gen_no
+
+        self.loss_names = []
+        self.visual_names = ['real_A']
+        # specify the training losses you want to print out. The training/test scripts will call <BaseModel.get_current_losses>
+        for i in range(1, self.mod_gen_no + 1):
+            self.loss_names.extend(['G_GAN_' + str(i), 'G_L1_' + str(i), 'D_real_' + str(i), 'D_fake_' + str(i)])
+            self.visual_names.extend(['fake_B_' + str(i), 'real_B_' + str(i)])
+
+        # specify the images you want to save/display. The training/test scripts will call <BaseModel.get_current_visuals>
+        # specify the models you want to save to the disk. The training/test scripts will call <BaseModel.save_networks> and <BaseModel.load_networks>
+        if self.is_train:
+            self.model_names = []
+            for i in range(1, self.mod_gen_no + 1):
+                self.model_names.extend(['G_' + str(i), 'D_' + str(i)])
+
+        else:  # during test time, only load G
+            self.model_names = []
+            for i in range(1, self.mod_gen_no + 1):
+                self.model_names.extend(['G_' + str(i)])
+
+        # define networks (both generator and discriminator)
+        self.netG = [None for _ in range(self.mod_gen_no)]
+        for i in range(self.mod_gen_no):
+            self.netG[i] = networks.define_G(self.opt.input_nc * self.opt.input_no, self.opt.output_nc, self.opt.ngf, self.opt.net_g, self.opt.norm,
+                                             not self.opt.no_dropout, self.opt.init_type, self.opt.init_gain, self.opt.gpu_ids, self.opt.padding)
+            print('***************************************')
+            print(self.opt.input_nc, self.opt.output_nc, self.opt.ngf, self.opt.net_g, self.opt.norm,
+                                             not self.opt.no_dropout, self.opt.init_type, self.opt.init_gain, self.opt.gpu_ids, self.opt.padding)
+            print('***************************************')
+
+        if self.is_train:  # define a discriminator; conditional GANs need to take both input and output images; Therefore, #channels for D is input_nc + output_nc
+            self.netD = [None for _ in range(self.mod_gen_no)]
+            for i in range(self.mod_gen_no):
+                self.netD[i] = networks.define_D(self.opt.input_nc * self.opt.input_no + self.opt.output_nc, self.opt.ndf, self.opt.net_d,
+                                                 self.opt.n_layers_D, self.opt.norm, self.opt.init_type, self.opt.init_gain,
+                                                 self.opt.gpu_ids)
+
+        if self.is_train:
+            # define loss functions
+            self.criterionGAN_mod = networks.GANLoss(self.opt.gan_mode).to(self.device)
+            self.criterionGAN_seg = networks.GANLoss(self.opt.gan_mode_s).to(self.device)
+
+            self.criterionSmoothL1 = torch.nn.SmoothL1Loss()
+
+            self.criterionVGG = networks.VGGLoss().to(self.device)
+
+            # initialize optimizers; schedulers will be automatically created by function <BaseModel.setup>.
+            params = []
+            for i in range(len(self.netG)):
+                params += list(self.netG[i].parameters())
+            self.optimizer_G = torch.optim.Adam(params, lr=opt.lr, betas=(opt.beta1, 0.999))
+
+            params = []
+            for i in range(len(self.netD)):
+                params += list(self.netD[i].parameters())
+            self.optimizer_D = torch.optim.Adam(params, lr=opt.lr, betas=(opt.beta1, 0.999))
+
+            self.optimizers.append(self.optimizer_G)
+            self.optimizers.append(self.optimizer_D)
+
+    def set_input(self, input):
+        """
+        Unpack input data from the dataloader and perform necessary pre-processing steps.
+
+        :param input (dict): include the input image and the output modalities
+        """
+        self.real_A_array = input['A']
+        As = [A.to(self.device) for A in self.real_A_array]
+        self.real_A = torch.cat(As, dim=1) # shape: 1, (3 x input_no), 512, 512
+
+        self.real_B_array = input['B']
+        self.real_B = []
+        for i in range(len(self.real_B_array)):
+            self.real_B.append(self.real_B_array[i].to(self.device))
+
+        self.real_concatenated = []
+        self.image_paths = input['A_paths']
+
+    def forward(self):
+        """Run forward pass; called by both functions <optimize_parameters> and <test>."""
+        self.fake_B = []
+        for i in range(self.mod_gen_no):
+            self.fake_B.append(self.netG[i](self.real_A))
+
+
+    def backward_D(self):
+        """Calculate GAN loss for the discriminators"""
+
+        pred_fake = []
+        for i in range(self.mod_gen_no):
+            pred_fake.append(self.netD[i](torch.cat((self.real_A, self.fake_B[i]), 1).detach()))
+
+        self.loss_D_fake = []
+        for i in range(self.mod_gen_no):
+            self.loss_D_fake.append(self.criterionGAN_mod(pred_fake[i], False))
+
+        pred_real = []
+        for i in range(self.mod_gen_no):
+            pred_real.append(self.netD[i](torch.cat((self.real_A, self.real_B[i]), 1)))
+
+        self.loss_D_real = []
+        for i in range(self.mod_gen_no):
+            self.loss_D_real.append(self.criterionGAN_mod(pred_real[i], True))
+
+        # combine losses and calculate gradients
+        # self.loss_D = (self.loss_D_fake[0] + self.loss_D_real[0]) * 0.5 * self.loss_D_weights[0]
+        self.loss_D = torch.tensor(0., device=self.device)
+        for i in range(0, self.mod_gen_no):
+            self.loss_D += (self.loss_D_fake[i] + self.loss_D_real[i]) * 0.5 * self.loss_D_weights[i]
+        self.loss_D.backward()
+
+    def backward_G(self):
+        """Calculate GAN and L1 loss for the generator"""
+        pred_fake = []
+        for i in range(self.mod_gen_no):
+            pred_fake.append(self.netD[i](torch.cat((self.real_A, self.fake_B[i]), 1)))
+
+        self.loss_G_GAN = []
+        self.loss_GS_GAN = []
+        for i in range(self.mod_gen_no):
+            self.loss_G_GAN.append(self.criterionGAN_mod(pred_fake[i], True))
+
+        # Second, G(A) = B
+        self.loss_G_L1 = []
+        self.loss_GS_L1 = []
+        for i in range(self.mod_gen_no):
+            self.loss_G_L1.append(self.criterionSmoothL1(self.fake_B[i], self.real_B[i]) * self.opt.lambda_L1)
+
+        #self.loss_G_VGG = []
+        #for i in range(self.mod_gen_no):
+        #    self.loss_G_VGG.append(self.criterionVGG(self.fake_B[i], self.real_B[i]) * self.opt.lambda_feat)
+
+        # self.loss_G = (self.loss_G_GAN[0] + self.loss_G_L1[0]) * self.loss_G_weights[0]
+        self.loss_G = torch.tensor(0., device=self.device)
+        for i in range(0, self.mod_gen_no):
+            self.loss_G += (self.loss_G_GAN[i] + self.loss_G_L1[i]) * self.loss_G_weights[i]
+        #    self.loss_G += (self.loss_G_GAN[i] + self.loss_G_L1[i] + self.loss_G_VGG[i]) * self.loss_G_weights[i]
+        self.loss_G.backward()
+
+    def optimize_parameters(self):
+        self.forward()  # compute fake images: G(A)
+        # update D
+        for i in range(self.mod_gen_no):
+            self.set_requires_grad(self.netD[i], True)  # enable backprop for D1
+
+        self.optimizer_D.zero_grad()  # set D's gradients to zero
+        self.backward_D()  # calculate gradients for D
+        self.optimizer_D.step()  # update D's weights
+
+        # update G
+        for i in range(self.mod_gen_no):
+            self.set_requires_grad(self.netD[i], False)
+
+        self.optimizer_G.zero_grad()  # set G's gradients to zero
+        self.backward_G()  # calculate graidents for G
+        self.optimizer_G.step()  # udpate G's weights

deepliif/models/__init__.py

@@ -56,8 +56,11 @@ def get_opt(model_dir, mode='test'):
             opt = Options(path_file=os.path.join(model_dir,'test_opt.txt'), mode=mode)
         except:
             opt = Options(path_file=os.path.join(model_dir,'train_opt.txt'), mode=mode)
+        opt.use_dp = False
+        opt.gpu_ids = list(range(torch.cuda.device_count()))
     return opt
 
+
 def find_model_using_name(model_name):
     """Import the module "models/[model_name]_model.py".
 
@@ -130,6 +133,10 @@ def load_eager_models(opt, devices):
                 net.eval()
                 net = disable_batchnorm_tracking_stats(net)
             
+            # SDG models when loaded are still DP.. not sure why
+            if isinstance(net, torch.nn.DataParallel):
+                net = net.module
+
             nets[name] = net
             nets[name].to(devices[name])
             
@@ -148,7 +155,7 @@ def init_nets(model_dir, eager_mode=False, opt=None, phase='test'):
     if opt is None:
         opt = get_opt(model_dir, mode=phase)
         opt.use_dp = False
-        print_options(opt)
+        #print_options(opt)
     
     if opt.model == 'DeepLIIF':
         net_groups = [
@@ -158,7 +165,7 @@ def init_nets(model_dir, eager_mode=False, opt=None, phase='test'):
             ('G4', 'G55'),
             ('G51',)
         ]
-    elif opt.model == 'DeepLIIFExt':
+    elif opt.model in ['DeepLIIFExt','SDG']:
         if opt.seg_gen:
             net_groups = [(f'G_{i+1}',f'GS_{i+1}') for i in range(opt.modalities_no)]
         else:
@@ -168,7 +175,8 @@ def init_nets(model_dir, eager_mode=False, opt=None, phase='test'):
 
     number_of_gpus_all = torch.cuda.device_count()
     number_of_gpus = len(opt.gpu_ids)
-    print(number_of_gpus)
+    #print(number_of_gpus)
+
     if number_of_gpus > 0:
         mapping_gpu_ids = {i:idx for i,idx in enumerate(opt.gpu_ids)}
         chunks = [itertools.chain.from_iterable(c) for c in chunker(net_groups, number_of_gpus)]
@@ -203,10 +211,7 @@ def run_torchserve(img, model_path=None, eager_mode=False, opt=None):
     opt: same as eager_mode
     """
     buffer = BytesIO()
-    if opt.model == 'DeepLIIFExt':
-        torch.save(transform(img.resize((1024, 1024))), buffer)
-    else:
-        torch.save(transform(img.resize((512, 512))), buffer)
+    torch.save(transform(img.resize((opt.scale_size, opt.scale_size))), buffer)
 
     torchserve_host = os.getenv('TORCHSERVE_HOST', 'http://localhost')
     res = requests.post(
@@ -226,10 +231,12 @@ def run_dask(img, model_path, eager_mode=False, opt=None):
     model_dir = os.getenv('DEEPLIIF_MODEL_DIR', model_path)
     nets = init_nets(model_dir, eager_mode, opt)
     
-    if opt.model == 'DeepLIIFExt':
-        ts = transform(img.resize((1024, 1024)))
+    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((512, 512)))
+        ts = transform(img.resize((opt.scale_size, opt.scale_size)))
+    
 
     @delayed
     def forward(input, model):
@@ -246,14 +253,20 @@ def run_dask(img, model_path, eager_mode=False, opt=None):
         lazy_segs['G51'] = forward(ts, nets['G51']).to(torch.device('cpu'))
         segs = compute(lazy_segs)[0]
     
-        seg_weights = [0.25, 0.25, 0.25, 0, 0.25]
-        seg = torch.stack([torch.mul(n, w) for n, w in zip(segs.values(), seg_weights)]).sum(dim=0)
+        weights = {
+            'G51': 0.25, # IHC
+            'G52': 0.25, # Hema
+            'G53': 0.25, # DAPI
+            'G54': 0.00, # Lap2
+            'G55': 0.25, # Marker
+        }
+        seg = torch.stack([torch.mul(segs[k], weights[k]) for k in segs.keys()]).sum(dim=0)
     
         res = {k: tensor_to_pil(v) for k, v in gens.items()}
         res['G5'] = tensor_to_pil(seg)
     
         return res
-    elif opt.model == 'DeepLIIFExt':
+    elif opt.model in ['DeepLIIFExt','SDG']:
         seg_map = {'G_' + str(i): 'GS_' + str(i) for i in range(1, opt.modalities_no + 1)}
         
         lazy_gens = {k: forward(ts, nets[k]) for k in seg_map}
@@ -268,14 +281,22 @@ def run_dask(img, model_path, eager_mode=False, opt=None):
     
         return res
     else:
-        raise Exception(f'run_dask() not implemented for {opt.model}')
+        raise Exception(f'run_dask() not fully implemented for {opt.model}')
 
-    
+
+def is_empty_old(tile):
+    # return True if np.mean(np.array(tile) - np.array(mean_background_val)) < 40 else False
+    if isinstance(tile, list): # for pair of tiles, only mark it as empty / no need for prediction if ALL tiles are empty
+        return all([True if calculate_background_area(t) > 98 else False for t in tile])
+    else:
+        return True if calculate_background_area(tile) > 98 else False
 
 
 def is_empty(tile):
-    # return True if np.mean(np.array(tile) - np.array(mean_background_val)) < 40 else False
-    return True if calculate_background_area(tile) > 98 else False
+    if isinstance(tile, list): # for pair of tiles, only mark it as empty / no need for prediction if ALL tiles are empty
+        return all([True if np.max(image_variance_rgb(tile)) < 15 else False for t in tile])
+    else:
+        return True if np.max(image_variance_rgb(tile)) < 15 else False
 
 
 def run_wrapper(tile, run_fn, model_path, eager_mode=False, opt=None):
@@ -290,7 +311,7 @@ def run_wrapper(tile, run_fn, model_path, eager_mode=False, opt=None):
             }
         else:
             return run_fn(tile, model_path, eager_mode, opt)
-    elif opt.model == 'DeepLIIFExt':
+    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)})
@@ -351,7 +372,7 @@ def inference(img, tile_size, overlap_size, model_path, use_torchserve=False, ea
               color_dapi=False, color_marker=False, opt=None):
     if not opt:
         opt = get_opt(model_path)
-        print_options(opt)
+        #print_options(opt)
     
     if opt.model == 'DeepLIIF':
         rescaled, rows, cols = format_image_for_tiling(img, tile_size, overlap_size)
@@ -359,28 +380,25 @@ def inference(img, tile_size, overlap_size, model_path, use_torchserve=False, ea
         run_fn = run_torchserve if use_torchserve else run_dask
     
         images = {}
-        images['Hema'] = create_image_for_stitching(tile_size, rows, cols)
-        images['DAPI'] = create_image_for_stitching(tile_size, rows, cols)
-        images['Lap2'] = create_image_for_stitching(tile_size, rows, cols)
-        images['Marker'] = create_image_for_stitching(tile_size, rows, cols)
-        images['Seg'] = create_image_for_stitching(tile_size, rows, cols)
+        d_modality2net = {'Hema':'G1',
+                          'DAPI':'G2',
+                          'Lap2':'G3',
+                          'Marker':'G4',
+                          'Seg':'G5'}
+        
+        for k in d_modality2net.keys():
+            images[k] = create_image_for_stitching(tile_size, rows, cols)
     
         for i in range(cols):
             for j in range(rows):
                 tile = extract_tile(rescaled, tile_size, overlap_size, i, j)
                 res = run_wrapper(tile, run_fn, model_path, eager_mode, opt)
-    
-                stitch_tile(images['Hema'], res['G1'], tile_size, overlap_size, i, j)
-                stitch_tile(images['DAPI'], res['G2'], tile_size, overlap_size, i, j)
-                stitch_tile(images['Lap2'], res['G3'], tile_size, overlap_size, i, j)
-                stitch_tile(images['Marker'], res['G4'], tile_size, overlap_size, i, j)
-                stitch_tile(images['Seg'], res['G5'], tile_size, overlap_size, i, j)
-    
-        images['Hema'] = images['Hema'].resize(img.size)
-        images['DAPI'] = images['DAPI'].resize(img.size)
-        images['Lap2'] = images['Lap2'].resize(img.size)
-        images['Marker'] = images['Marker'].resize(img.size)
-        images['Seg'] = images['Seg'].resize(img.size)
+                
+                for modality_name, net_name in d_modality2net.items():
+                    stitch_tile(images[modality_name], res[net_name], tile_size, overlap_size, i, j)
+        
+        for modality_name, output_img in images.items():
+            images[modality_name] = output_img.resize(img.size)
     
         if color_dapi:
             matrix = (       0,        0,        0, 0,
@@ -400,42 +418,88 @@ def inference(img, tile_size, overlap_size, model_path, use_torchserve=False, ea
         #param_dict = read_train_options(model_path)
         #modalities_no = int(param_dict['modalities_no']) if param_dict else 4
         #seg_gen = (param_dict['seg_gen'] == 'True') if param_dict else True
-    
-        tiles = list(generate_tiles(img, tile_size, overlap_size))
-    
+        
+        
+        rescaled, rows, cols = format_image_for_tiling(img, tile_size, overlap_size)
         run_fn = run_torchserve if use_torchserve else run_dask
-        res = [Tile(t.i, t.j, run_wrapper(t.img, run_fn, model_path, eager_mode, opt)) for t in tiles]
     
         def get_net_tiles(n):
             return [Tile(t.i, t.j, t.img[n]) for t in res]
     
         images = {}
-    
-        for i in range(1, opt.modalities_no + 1):
-            images['mod' + str(i)] = stitch(get_net_tiles('G_' + str(i)), tile_size, overlap_size).resize(img.size)
-    
+        d_modality2net = {f'mod{i}':f'G_{i}' for i in range(1, opt.modalities_no + 1)}
         if opt.seg_gen:
-            for i in range(1, opt.modalities_no + 1):
-                images['Seg' + str(i)] = stitch(get_net_tiles('GS_' + str(i)), tile_size, overlap_size).resize(img.size)
+            d_modality2net.update({f'Seg{i}':f'GS_{i}' for i in range(1, opt.modalities_no + 1)})
+        
+        for k in d_modality2net.keys():
+            images[k] = create_image_for_stitching(tile_size, rows, cols)
     
+        for i in range(cols):
+            for j in range(rows):
+                tile = extract_tile(rescaled, tile_size, overlap_size, i, j)
+                res = run_wrapper(tile, run_fn, model_path, eager_mode, opt)
+                
+                for modality_name, net_name in d_modality2net.items():
+                    stitch_tile(images[modality_name], res[net_name], tile_size, overlap_size, i, j)
+        
+        for modality_name, output_img in images.items():
+            images[modality_name] = output_img.resize(img.size)
+            
+        return images
+        
+    elif opt.model == 'SDG':
+        # SDG could have multiple input images / modalities
+        # the input hence could be a rectangle
+        # we split the input to get each modality image one by one
+        # then create tiles for each of the modality images
+        # tile_pair is a list that contains the tiles at the given location for each modality image
+        # l_tile_pair is a list of tile_pair that covers all locations
+        # for inference, each tile_pair is used to get the output at the given location
+        w, h = img.size
+        w2 = int(w / opt.input_no)
+        
+        l_img = []        
+        for i in range(opt.input_no):
+            img_i = img.crop((w2 * i, 0, w2 * (i+1), h))
+            rescaled_img_i, rows, cols = format_image_for_tiling(img_i, tile_size, overlap_size)
+            l_img.append(rescaled_img_i)
+        
+        run_fn = run_torchserve if use_torchserve else run_dask
+        
+        images = {}
+        d_modality2net = {f'mod{i}':f'G_{i}' for i in range(1, opt.modalities_no + 1)}
+        for k in d_modality2net.keys():
+            images[k] = create_image_for_stitching(tile_size, rows, cols)
+        
+        for i in range(cols):
+            for j in range(rows):
+                tile_pair = [extract_tile(rescaled, tile_size, overlap_size, i, j) for rescaled in l_img]
+                res = run_wrapper(tile_pair, run_fn, model_path, eager_mode, opt)
+                
+                for modality_name, net_name in d_modality2net.items():
+                    stitch_tile(images[modality_name], res[net_name], tile_size, overlap_size, i, j)
+        
+        for modality_name, output_img in images.items():
+            images[modality_name] = output_img.resize((w2,w2))
+        
         return images
     
     else:
         raise Exception(f'inference() not implemented for model {opt.model}')
 
 
-def postprocess(orig, images, tile_size, seg_thresh=150, size_thresh='default', marker_thresh='default', size_thresh_upper=None, opt=None):
-    if opt.model == 'DeepLIIF':
+def postprocess(orig, images, tile_size, model, seg_thresh=150, size_thresh='auto', marker_thresh='auto', size_thresh_upper=None):
+    if model == 'DeepLIIF':
         resolution = '40x' if tile_size > 384 else ('20x' if tile_size > 192 else '10x')
         overlay, refined, scoring = compute_results(np.array(orig), np.array(images['Seg']),
-                                                    np.array(images['Marker'].convert('L')), resolution,
-                                                    seg_thresh, size_thresh, marker_thresh, size_thresh_upper)
+                                                    np.array(images['Marker'].convert('L')) if 'Marker' in images else None,
+                                                    resolution, seg_thresh, size_thresh, marker_thresh, size_thresh_upper)
         processed_images = {}
         processed_images['SegOverlaid'] = Image.fromarray(overlay)
         processed_images['SegRefined'] = Image.fromarray(refined)
         return processed_images, scoring
 
-    elif opt.model == 'DeepLIIFExt':
+    elif model == 'DeepLIIFExt':
         resolution = '40x' if tile_size > 768 else ('20x' if tile_size > 384 else '10x')
         processed_images = {}
         scoring = {}
@@ -452,7 +516,7 @@ def postprocess(orig, images, tile_size, seg_thresh=150, size_thresh='default',
         return processed_images, scoring
 
     else:
-        raise Exception(f'postprocess() not implemented for model {opt.model}')
+        raise Exception(f'postprocess() not implemented for model {model}')
 
 
 def infer_modalities(img, tile_size, model_dir, eager_mode=False,
@@ -467,17 +531,21 @@ def infer_modalities(img, tile_size, model_dir, eager_mode=False,
     if opt is None:
         opt = get_opt(model_dir)
         opt.use_dp = False
-        print_options(opt)
+        #print_options(opt)
     
     if not tile_size:
         tile_size = check_multi_scale(Image.open('./images/target.png').convert('L'),
                                       img.convert('L'))
     tile_size = int(tile_size)
+    
+    # for those with multiple input modalities, find the correct size to calculate overlap_size
+    input_no = opt.input_no if hasattr(opt, 'input_no') else 1
+    img_size = (img.size[0] / input_no, img.size[1]) # (width, height)
 
     images = inference(
         img,
         tile_size=tile_size,
-        overlap_size=compute_overlap(img.size, tile_size),
+        overlap_size=compute_overlap(img_size, tile_size),
         model_path=model_dir,
         eager_mode=eager_mode,
         color_dapi=color_dapi,
@@ -486,7 +554,7 @@ def infer_modalities(img, tile_size, model_dir, eager_mode=False,
     )
     
     if not hasattr(opt,'seg_gen') or (hasattr(opt,'seg_gen') and opt.seg_gen): # the first condition accounts for old settings of deepliif; the second refers to deepliifext models
-        post_images, scoring = postprocess(img, images, tile_size, opt=opt)
+        post_images, scoring = postprocess(img, images, tile_size, opt.model)
         images = {**images, **post_images}
         return images, scoring
     else:

deepliif/options/__init__.py

@@ -13,7 +13,6 @@ def read_model_params(file_addr):
             key = line.split(':')[0].strip()
             val = line.split(':')[1].split('[')[0].strip()
             param_dict[key] = val
-    print(param_dict)
     return param_dict
 
 class Options:
@@ -32,19 +31,7 @@ class Options:
                 else:
                     setattr(self,k,v)
             except:
-                setattr(self,k,v)
-        
-        if mode != 'train':
-            # to account for old settings where gpu_ids value is an integer, not a tuple
-            if isinstance(self.gpu_ids,int):
-                self.gpu_ids = (self.gpu_ids,)
-            
-            # to account for old settings before modalities_no was introduced
-            if not hasattr(self,'modalities_no') and hasattr(self,'targets_no'):
-                self.modalities_no = self.targets_no - 1
-                del self.targets_no
-            
-            
+                setattr(self,k,v)            
 
         if mode == 'train':
             self.is_train = True
@@ -71,32 +58,78 @@ class Options:
             self.checkpoints_dir = str(model_dir.parent)
             self.name = str(model_dir.name)
             
-            self.gpu_ids = [] # gpu_ids is only used by eager mode, set to empty / cpu to be the same as the old settings; non-eager mode will use all gpus
+            #self.gpu_ids = [] # gpu_ids is only used by eager mode, set to empty / cpu to be the same as the old settings; non-eager mode will use all gpus
+            
+            # to account for old settings where gpu_ids value is an integer, not a tuple
+            if isinstance(self.gpu_ids,int):
+                self.gpu_ids = (self.gpu_ids,)
+            
+            # to account for old settings before modalities_no was introduced
+            if not hasattr(self,'modalities_no') and hasattr(self,'targets_no'):
+                self.modalities_no = self.targets_no - 1
+                del self.targets_no
+            
+            # to account for old settings: same as in cli.py train
+            if not hasattr(self,'seg_no'):
+              if self.model == 'DeepLIIF':
+                  self.seg_no = 1
+              elif self.model == 'DeepLIIFExt':
+                  if self.seg_gen:
+                      self.seg_no = self.modalities_no
+                  else:
+                      self.seg_no = 0
+              elif self.model == 'SDG':
+                  self.seg_no = 0
+                  self.seg_gen = False
+              else:
+                  raise Exception(f'seg_gen cannot be automatically determined for {opt.model}')
+            
+            # to account for old settings: prior to SDG, our models only have 1 input image
+            if not hasattr(self,'input_no'):
+                self.input_no = 1
+            
+            # to account for old settings: before adding scale_size
+            if not hasattr(self, 'scale_size'):
+                if self.model in ['DeepLIIF','SDG']:
+                    self.scale_size = 512
+                elif self.model == 'DeepLIIFExt':
+                    self.scale_size = 1024
+                else:
+                  raise Exception(f'scale_size cannot be automatically determined for {opt.model}')
+
+            
     
     def _get_kwargs(self):
         common_attr = ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
         l_args = [x for x in dir(self) if x not in common_attr]
         return {k:getattr(self,k) for k in l_args}
-            
-def print_options(opt):
-    """Print and save options
 
-    It will print both current options and default values(if different).
-    It will save options into a text file / [checkpoints_dir] / opt.txt
-    """
+def format_options(opt):
     message = ''
     message += '----------------- Options ---------------\n'
     for k, v in sorted(vars(opt).items()):
         comment = ''
         message += '{:>25}: {:<30}{}\n'.format(str(k), str(v), comment)
     message += '----------------- End -------------------'
-    print(message)
+    return message
+    
+def print_options(opt, save=False):
+    """Print (and save) options
 
+    It will print both current options and default values(if different).
+    If save=True, it will save options into a text file / [checkpoints_dir] / opt.txt
+    """
+    message = format_options(opt)
+    print(message)
+    
     # save to the disk
-    if opt.phase == 'train':
-        expr_dir = os.path.join(opt.checkpoints_dir, opt.name)
-        mkdirs(expr_dir)
-        file_name = os.path.join(expr_dir, '{}_opt.txt'.format(opt.phase))
-        with open(file_name, 'wt') as opt_file:
-            opt_file.write(message)
-        opt_file.write('\n')
+    if save:
+        save_options(opt)
+
+def save_options(opt):
+    message = format_options(opt)
+    expr_dir = os.path.join(opt.checkpoints_dir, opt.name)
+    mkdirs(expr_dir)
+    file_name = os.path.join(expr_dir, '{}_opt.txt'.format(opt.phase))
+    with open(file_name, 'wt') as opt_file:
+        opt_file.write(message+'\n')

deepliif/postprocessing.py

@@ -401,23 +401,30 @@ def calc_default_marker_thresh(marker):
         return 0
 
 
-def compute_results(orig, seg, marker, resolution=None, seg_thresh=150, size_thresh='default', marker_thresh='default', size_thresh_upper=None):
+def compute_results(orig, seg, marker, resolution=None, seg_thresh=150, size_thresh='auto', marker_thresh='auto', size_thresh_upper=None):
     mask = create_posneg_mask(seg, seg_thresh)
     mark_background(mask)
 
-    if size_thresh == 'default':
+    if size_thresh == 'auto':
         size_thresh = calc_default_size_thresh(mask, resolution)
-    if marker_thresh == 'default':
+    if marker_thresh is None:
+        marker_thresh = 0
+        marker = None
+    elif marker_thresh == 'auto':
         marker_thresh = calc_default_marker_thresh(marker)
 
-    counts = compute_cell_classification(mask, marker, size_thresh, marker_thresh, size_thresh_upper=None)
+    counts = compute_cell_classification(mask, marker, size_thresh, marker_thresh, size_thresh_upper)
     enlarge_cell_boundaries(mask)
 
     scoring = {
         'num_total': counts['num_total'],
         'num_pos': counts['num_pos'],
         'num_neg': counts['num_neg'],
-        'percent_pos': round(counts['num_pos'] / counts['num_total'] * 100, 1) if counts['num_pos'] > 0 else 0
+        'percent_pos': round(counts['num_pos'] / counts['num_total'] * 100, 1) if counts['num_pos'] > 0 else 0,
+        'prob_thresh': seg_thresh,
+        'size_thresh': size_thresh,
+        'size_thresh_upper': size_thresh_upper,
+        'marker_thresh': marker_thresh if marker is not None else None,
     }
 
     overlay = np.copy(orig)

deepliif/util/__init__.py

@@ -164,6 +164,28 @@ def adjust_background_tile(img):
     return image
 
 
+def image_variance_gray(img):
+    px = np.asarray(img) if img.mode == 'L' else np.asarray(img.convert('L'))
+    idx = np.logical_and(px != 255, px != 0)
+    val = px[idx]
+    if val.shape[0] == 0:
+        return 0
+    var = np.var(val)
+    return var
+
+
+def image_variance_rgb(img):
+    px = np.asarray(img) if img.mode == 'RGB' else np.asarray(img.convert('RGB'))
+    nonwhite = np.any(px != [255, 255, 255], axis=-1)
+    nonblack = np.any(px != [0, 0, 0], axis=-1)
+    idx = np.logical_and(nonwhite, nonblack)
+    val = px[idx]
+    if val.shape[0] == 0:
+        return [0, 0, 0]
+    var = np.var(val, axis=0)
+    return var
+
+
 def read_bioformats_image_with_reader(path, channel=0, region=(0, 0, 0, 0)):
     """
     Using this function, you can read a specific region of a large image by giving the region bounding box (XYWH format)

deepliif/util/util.py

@@ -48,7 +48,23 @@ def save_image(image_numpy, image_path, aspect_ratio=1.0):
         image_numpy (numpy array) -- input numpy array
         image_path (str)          -- the path of the image
     """
-
+    x, y, nc = image_numpy.shape
+    
+    if nc > 3:
+        if nc % 3 == 0:
+            nc_img = 3
+            no_img = nc // nc_img
+            
+        elif nc % 2 == 0:
+            nc_img = 2
+            no_img = nc // nc_img
+        else:
+            nc_img = 1
+            no_img = nc // nc_img
+        print(f'image (numpy) has {nc}>3 channels, inferred to have {no_img} images each with {nc_img} channel(s)')
+        l_image_numpy = np.dsplit(image_numpy,[nc_img*i for i in range(1,no_img)])
+        image_numpy = np.concatenate(l_image_numpy, axis=1) # stack horizontally
+        
     image_pil = Image.fromarray(image_numpy)
     h, w, _ = image_numpy.shape
 

{deepliif-1.1.8.dist-info → deepliif-1.1.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepliif
-Version: 1.1.8
+Version: 1.1.10
 Summary: DeepLIIF: Deep-Learning Inferred Multiplex Immunofluorescence for Immunohistochemical Image Quantification
 Home-page: https://github.com/nadeemlab/DeepLIIF
 Author: Parmida93
@@ -61,6 +61,9 @@ segmentation.*
 
 © This code is made available for non-commercial academic purposes.
 
+![Version](https://img.shields.io/static/v1?label=latest&message=v1.1.9&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 
 brown/DAB markers -- BCL2, BCL6, CD10, CD3/CD8, Ki67) with corresponding DeepLIIF-generated hematoxylin/mpIF modalities 
 and classified (positive (red) and negative (blue) cell) segmentation masks. (a) Overview of DeepLIIF. Given an IHC 
@@ -132,7 +135,7 @@ deepliif prepare-training-data --input-dir /path/to/input/images
 To train a model:
 ```
 deepliif train --dataroot /path/to/input/images 
-                --name Model_Name 
+               --name Model_Name 
 ```
 or
 ```
@@ -178,7 +181,7 @@ The installed `deepliif` uses Dask to perform inference on the input IHC images.
 Before running the `test` command, the model files must be serialized using Torchscript.
 To serialize the model files:
 ```
-deepliif serialize --models-dir /path/to/input/model/files
+deepliif serialize --model-dir /path/to/input/model/files
                    --output-dir /path/to/output/model/files
 ```
 * By default, the model files are expected to be located in `DeepLIIF/model-server/DeepLIIF_Latest_Model`.
@@ -187,15 +190,17 @@ deepliif serialize --models-dir /path/to/input/model/files
 ## Testing
 To test the model:
 ```
-deepliif test --input-dir /path/to/input/images 
-              --output-dir /path/to/output/images 
-              --model-dir path/to/the/serialized/model
+deepliif test --input-dir /path/to/input/images
+              --output-dir /path/to/output/images
+              --model-dir /path/to/the/serialized/model
               --tile-size 512
 ```
 or
 ```
-python test.py --dataroot /path/to/input/images 
-               --name Model_Name  
+python test.py --dataroot /path/to/input/images
+               --results_dir /path/to/output/images
+               --checkpoints_dir /path/to/model/files
+               --name Model_Name
 ```
 * The latest version of the pretrained models can be downloaded [here](https://zenodo.org/record/4751737#.YKRTS0NKhH4).
 * Before running test on images, the model files must be serialized as described above.
@@ -216,7 +221,7 @@ Based on the available GPU resources, the region-size can be changed.
 ```
 deepliif test --input-dir /path/to/input/images 
               --output-dir /path/to/output/images 
-              --model-dir path/to/the/serialized/model
+              --model-dir /path/to/the/serialized/model
               --tile-size 512
               --region-size 20000
 ```
@@ -257,25 +262,61 @@ If you don't have access to GPU or appropriate hardware and don't want to instal
 
 ![DeepLIIF Website Demo](images/deepliif-website-demo-03.gif)
 
-DeepLIIF can also be accessed programmatically through an endpoint by posting a multipart-encoded request
-containing the original image file:
+## Cloud API Endpoints
+
+DeepLIIF can also be accessed programmatically through an endpoint by posting a multipart-encoded request containing the original image file, along with optional parameters including postprocessing thresholds:
 
 ```
 POST /api/infer
 
-Parameters
+File Parameter:
+
+  img (required)
+    Image on which to run DeepLIIF.
+
+Query String Parameters:
+
+  resolution
+    Resolution used to scan the slide (10x, 20x, 40x). Default is 40x.
 
-img (required)
-file: image to run the models on
+  pil
+    If present, use Pillow to load the image instead of Bio-Formats. Pillow is
+    faster, but works only on common image types (png, jpeg, etc.).
 
-resolution
-string: resolution used to scan the slide (10x, 20x, 40x), defaults to 20x 
+  slim
+    If present, return only the refined segmentation result image.
 
-pil
-boolean: if true, use PIL.Image.open() to load the image, instead of python-bioformats
+  nopost
+    If present, do not perform postprocessing (returns only inferred images).
 
-slim
-boolean: if true, return only the segmentation result image
+  prob_thresh
+    Probability threshold used in postprocessing the inferred segmentation map
+    image. The segmentation map value must be above this value in order for a
+    pixel to be included in the final cell segmentation. Valid values are an
+    integer in the range 0-254. Default is 150.
+
+  size_thresh
+    Lower threshold for size gating the cells in postprocessing. Segmented
+    cells must have more pixels than this value in order to be included in the
+    final cell segmentation. Valid values are 0, a positive integer, or 'auto'.
+    'Auto' will try to automatically determine this lower bound for size gating
+    based on the distribution of detected cell sizes. Default is 'auto'.
+
+  size_thresh_upper
+    Upper threshold for size gating the cells in postprocessing.  Segmented
+    cells must have less pixels that this value in order to be included in the
+    final cell segmentation. Valid values are a positive integer or 'none'.
+    'None' will use no upper threshold in size gating. Default is 'none'.
+
+  marker_thresh
+    Threshold for the effect that the inferred marker image will have on the
+    postprocessing classification of cells as positive.  If any corresponding
+    pixel in the marker image for a cell is above this threshold, the cell will
+    be classified as being positive regardless of the values from the inferred
+    segmentation image. Valid values are an integer in the range 0-255, 'none',
+    or 'auto'. 'None' will not use the marker image during classification.
+    'Auto' will automatically determine a threshold from the marker image.
+    Default is 'auto'.
 ```
 
 For example, in Python:
@@ -293,15 +334,118 @@ from PIL import Image
 images_dir = './Sample_Large_Tissues'
 filename = 'ROI_1.png'
 
+root = os.path.splitext(filename)[0]
+
 res = requests.post(
     url='https://deepliif.org/api/infer',
     files={
-        'img': open(f'{images_dir}/{filename}', 'rb')
+        'img': open(f'{images_dir}/{filename}', 'rb'),
     },
-    # optional param that can be 10x, 20x (default) or 40x
     params={
-        'resolution': '20x'
-    }
+        'resolution': '40x',
+    },
+)
+
+data = res.json()
+
+def b64_to_pil(b):
+    return Image.open(BytesIO(base64.b64decode(b.encode())))
+
+for name, img in data['images'].items():
+    with open(f'{images_dir}/{root}_{name}.png', 'wb') as f:
+        b64_to_pil(img).save(f, format='PNG')
+
+with open(f'{images_dir}/{root}_scoring.json', 'w') as f:
+    json.dump(data['scoring'], f, indent=2)
+print(json.dumps(data['scoring'], indent=2))
+```
+
+If you have previously run DeepLIIF on an image and want to postprocess it with different thresholds, the postprocessing routine can be called directly using the previously inferred results:
+
+```
+POST /api/postprocess
+
+File Parameters:
+
+  img (required)
+    Image on which DeepLIIF was run.
+
+  seg_img (required)
+    Inferred segmentation image previously generated by DeepLIIF.
+
+  marker_img (optional)
+    Inferred marker image previously generated by DeepLIIF.  If this is
+    omitted, then the marker image will not be used in classification.
+
+Query String Parameters:
+
+  resolution
+    Resolution used to scan the slide (10x, 20x, 40x). Default is 40x.
+
+  pil
+    If present, use Pillow to load the original image instead of Bio-Formats.
+    Pillow is faster, but works only on common image types (png, jpeg, etc.).
+    Pillow is always used to open the seg_img and marker_img files.
+
+  prob_thresh
+    Probability threshold used in postprocessing the inferred segmentation map
+    image. The segmentation map value must be above this value in order for a
+    pixel to be included in the final cell segmentation. Valid values are an
+    integer in the range 0-254. Default is 150.
+
+  size_thresh
+    Lower threshold for size gating the cells in postprocessing. Segmented
+    cells must have more pixels than this value in order to be included in the
+    final cell segmentation. Valid values are 0, a positive integer, or 'auto'.
+    'Auto' will try to automatically determine this lower bound for size gating
+    based on the distribution of detected cell sizes. Default is 'auto'.
+
+  size_thresh_upper
+    Upper threshold for size gating the cells in postprocessing.  Segmented
+    cells must have less pixels that this value in order to be included in the
+    final cell segmentation. Valid values are a positive integer or 'none'.
+    'None' will use no upper threshold in size gating. Default is 'none'.
+
+  marker_thresh
+    Threshold for the effect that the inferred marker image will have on the
+    postprocessing classification of cells as positive.  If any corresponding
+    pixel in the marker image for a cell is above this threshold, the cell will
+    be classified as being positive regardless of the values from the inferred
+    segmentation image. Valid values are an integer in the range 0-255, 'none',
+    or 'auto'. 'None' will not use the marker image during classification.
+    'Auto' will automatically determine a threshold from the marker image.
+    Default is 'auto'. (If marker_img is not supplied, this has no effect.)
+```
+
+For example, in Python:
+
+```python
+import os
+import json
+import base64
+from io import BytesIO
+
+import requests
+from PIL import Image
+
+# Use the sample images from the main DeepLIIF repo
+images_dir = './Sample_Large_Tissues'
+filename = 'ROI_1.png'
+
+root = os.path.splitext(filename)[0]
+
+res = requests.post(
+    url='https://deepliif.org/api/infer',
+    files={
+        'img': open(f'{images_dir}/{filename}', 'rb'),
+        'seg_img': open(f'{images_dir}/{root}_Seg.png', 'rb'),
+        'marker_img': open(f'{images_dir}/{root}_Marker.png', 'rb'),
+    },
+    params={
+        'resolution': '40x',
+        'pil': True,
+        'size_thresh': 250,
+    },
 )
 
 data = res.json()
@@ -310,10 +454,11 @@ def b64_to_pil(b):
     return Image.open(BytesIO(base64.b64decode(b.encode())))
 
 for name, img in data['images'].items():
-    output_filepath = f'{images_dir}/{os.path.splitext(filename)[0]}_{name}.png'
-    with open(output_filepath, 'wb') as f:
+    with open(f'{images_dir}/{root}_{name}.png', 'wb') as f:
         b64_to_pil(img).save(f, format='PNG')
 
+with open(f'{images_dir}/{root}_scoring.json', 'w') as f:
+    json.dump(data['scoring'], f, indent=2)
 print(json.dumps(data['scoring'], indent=2))
 ```
 

{deepliif-1.1.8.dist-info → deepliif-1.1.10.dist-info}/RECORD

@@ -1,9 +1,9 @@
-cli.py,sha256=elGu-9di_LcUXPsWWknWPevbaTv2r2rpORVPH5lsnAU,39723
+cli.py,sha256=iU9YxO65T1rxX2Mx9f9LsEPC4o_ZXO-wH_-FUjIA1so,40088
 deepliif/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deepliif/postprocessing.py,sha256=QrTT7HodlLyrNFrI9hJowkQet6YVVIosf9B1iK4ajQk,17327
+deepliif/postprocessing.py,sha256=cM-cYVidY691Sjb1-B8a1jkLq5UR_hTCbuKzuF4765o,17589
 deepliif/train.py,sha256=-ZORL5vQrD0_Jq2Adgr3w8vJ7L1QcAgNTqMnBgtixgk,15757
 deepliif/data/__init__.py,sha256=euf9eUboK4RYR0jvdiyZDgPGozC1Nv7WRqRbTxSZD6A,5281
-deepliif/data/aligned_dataset.py,sha256=bAofVfgMwtb8Exe4EtQ3aP2ZYewBT4N_X8BDWSeFFj0,4405
+deepliif/data/aligned_dataset.py,sha256=6qNFLXXW1phuIfNhCJSaLfOc-KN2kl7EuUdmyAPPU4I,5148
 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
@@ -12,23 +12,24 @@ deepliif/data/template_dataset.py,sha256=PCDBnFRzRKReaeWgKUZmW0LrzRByI9adrKDJ6SN
 deepliif/data/unaligned_dataset.py,sha256=m7j-CX-hkXbhg96NSEcaCagNVhTuXKkMsBADdMEJDBA,3393
 deepliif/models/DeepLIIFExt_model.py,sha256=Sc60rOfDJuoGrJ1CYe4beAg6as6F0o864AO6ZB7paBY,14527
 deepliif/models/DeepLIIF_model.py,sha256=ECZyM9jzoJAWSgB1ProBoarVuGcbScQMaSkRjSMgt0k,20872
-deepliif/models/__init__.py,sha256=0vseZQ6LX6zrUQuMnmpcZDjyyjuVb_vMBi_hyiAVwcw,22565
+deepliif/models/SDG_model.py,sha256=xcZCTMNyJbcB78I1c8KtYVIB6OWL7WSMKdCxNemIzxs,9074
+deepliif/models/__init__.py,sha256=Bjya0xOHjoJa0Wnfiwby-gzJaUzfVsVDS4S_37Uid-g,25597
 deepliif/models/base_model.py,sha256=HKcUOBHtL-zLs5ZcmeXT-ZV_ubqsSUo4wMCQ0W27YHU,15583
 deepliif/models/networks.py,sha256=bN4yjRdE413efUESq8pvhzPDgFCTwFKXyQOrRqHckWY,32177
-deepliif/options/__init__.py,sha256=nm231wh_hQw1mX0AfXZu7-cx6WZdxURsE-jvnjlHQzE,4581
+deepliif/options/__init__.py,sha256=-syiyTK_oAeTLCBDm0bz1f_1jI3VK3LCwo2UNwOz6eM,5949
 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=dPkYGAy8s8JL7srZIkIhDuKdpQwVyf2Nsy5ABWlLFtg,16924
+deepliif/util/__init__.py,sha256=5lkf-6R03VPnLXABKec_nx3BmXM-ZGQd3SZ1ft-koHA,17573
 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=bTArzuhIMGgGweH0v5rkiHrqBxc24BDv12rssOE9OoI,4636
+deepliif/util/util.py,sha256=9MNgqthJZYjl5-TJm5-sjWvMfPBz8F4P5K0RHXRQhfY,5241
 deepliif/util/visualizer.py,sha256=5V1lWidHqssJX21jn1P5-bOVgtrEXKVaQgnMWAsMfqg,15636
-deepliif-1.1.8.dist-info/LICENSE.md,sha256=HlZw_UPS6EtJimJ_Ci7xKh-S5Iubs0Z8y8E6EZ3ZNyE,956
-deepliif-1.1.8.dist-info/METADATA,sha256=kXAkqKbOVhBUAhMuF7vTqZAXr8rJuLKU8dykdnr47jQ,25075
-deepliif-1.1.8.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-deepliif-1.1.8.dist-info/entry_points.txt,sha256=f70-10j2q68o_rDlsE3hspnv4ejlDnXwwGZ9JJ-3yF4,37
-deepliif-1.1.8.dist-info/top_level.txt,sha256=vLDK5YKmDz08E7PywuvEjAo7dM5rnIpsjR4c0ubQCnc,13
-deepliif-1.1.8.dist-info/RECORD,,
+deepliif-1.1.10.dist-info/LICENSE.md,sha256=HlZw_UPS6EtJimJ_Ci7xKh-S5Iubs0Z8y8E6EZ3ZNyE,956
+deepliif-1.1.10.dist-info/METADATA,sha256=iApT5xf7jFaGZoqda3fQ68c3WCnE6e_nUxjFcxVInHk,31173
+deepliif-1.1.10.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+deepliif-1.1.10.dist-info/entry_points.txt,sha256=f70-10j2q68o_rDlsE3hspnv4ejlDnXwwGZ9JJ-3yF4,37
+deepliif-1.1.10.dist-info/top_level.txt,sha256=vLDK5YKmDz08E7PywuvEjAo7dM5rnIpsjR4c0ubQCnc,13
+deepliif-1.1.10.dist-info/RECORD,,