deepliif 1.1.6__tar.gz → 1.1.8__tar.gz

{deepliif-1.1.6/deepliif.egg-info → deepliif-1.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepliif
-Version: 1.1.6
+Version: 1.1.8
 Summary: DeepLIIF: Deep-Learning Inferred Multiplex Immunofluorescence for Immunohistochemical Image Quantification
 Home-page: https://github.com/nadeemlab/DeepLIIF
 Author: Parmida93
@@ -16,20 +16,18 @@ License-File: LICENSE.md
     <img src="./images/DeepLIIF_logo.png" width="50%">
     <h3 align="center"><strong>Deep-Learning Inferred Multiplex Immunofluorescence for Immunohistochemical Image Quantification</strong></h3>
     <p align="center">
-    <a href="https://doi.org/10.1101/2021.05.01.442219">Journal Preprint</a>
+    <a href="https://rdcu.be/cKSBz">Nature MI'22</a>
     |
-    <a href="https://rdcu.be/cKSBz">Journal Link</a>
+    <a href="https://openaccess.thecvf.com/content/CVPR2022/html/Ghahremani_DeepLIIF_An_Online_Platform_for_Quantification_of_Clinical_Pathology_Slides_CVPR_2022_paper.html">CVPR'22</a>
     |
-    <a href="https://openaccess.thecvf.com/content/CVPR2022/html/Ghahremani_DeepLIIF_An_Online_Platform_for_Quantification_of_Clinical_Pathology_Slides_CVPR_2022_paper.html">CVPR Link</a>
+    <a href="https://arxiv.org/abs/2305.16465">MICCAI'23</a>
+    |
+    <a href="https://onlinelibrary.wiley.com/share/author/4AEBAGEHSZE9GDP3H8MN?target=10.1111/his.15048">Histopathology'23</a>
     |
     <a href="https://deepliif.org/">Cloud Deployment</a>
     |
     <a href="https://nadeemlab.github.io/DeepLIIF/">Documentation</a>
     |
-    <a href="#docker">Docker</a>
-    |
-    <a href="https://github.com/nadeemlab/DeepLIIF/tree/main/ImageJ_Plugin">ImageJ Plugin</a>
-    |
     <a href="#support">Support</a>
   </p>
 </p>
@@ -221,8 +219,7 @@ on how to deploy the model with Torchserve and for an example of how to run the
 We provide a Dockerfile that can be used to run the DeepLIIF models inside a container.
 First, you need to install the [Docker Engine](https://docs.docker.com/engine/install/ubuntu/).
 After installing the Docker, you need to follow these steps:
-* Download the pretrained model and place them in DeepLIIF/checkpoints/DeepLIIF_Latest_Model.
-* Change XXX of the **WORKDIR** line in the **DockerFile** to the directory containing the DeepLIIF project. 
+* Download the pretrained model [here](https://zenodo.org/record/4751737#.YKRTS0NKhH4) and place them in DeepLIIF/model-server/DeepLIIF_Latest_Model.
 * To create a docker image from the docker file:
 ```
 docker build -t cuda/deepliif .
@@ -231,7 +228,7 @@ The image is then used as a base. You can copy and use it to run an application.
 environment in which to run, referred to as a container.
 * To create and run a container:
 ```
- docker run -it -v `pwd`:`pwd` -w `pwd` cuda/deepliif deepliif test --input-dir Sample_Large_Tissues
+ docker run -it -v `pwd`:`pwd` -w `pwd` cuda/deepliif deepliif test --input-dir Sample_Large_Tissues --tile-size 512
 ```
 When you run a container from the image, the `deepliif` CLI will be available.
 You can easily run any CLI command in the activated environment and copy the results from the docker container to the host.
@@ -356,6 +353,9 @@ for the same slide (de novo staining) and would like to contribute that data for
 co-registration, whole-cell multiplex segmentation via [ImPartial](https://github.com/nadeemlab/ImPartial), train the 
 DeepLIIF model and release back to the community with full credit to the contributors.
 
+- [x] **Memorial Sloan Kettering Cancer Center** [AI-ready immunohistochemistry and multiplex immunofluorescence dataset](https://zenodo.org/record/4751737#.YKRTS0NKhH4) for breast, lung, and bladder cancers (**Nature Machine Intelligence'22**)
+- [x] **Moffitt Cancer Center** [AI-ready multiplex immunofluorescence and multiplex immunohistochemistry dataset](https://wiki.cancerimagingarchive.net/pages/viewpage.action?pageId=70226184) for head-and-neck squamous cell carcinoma (**MICCAI'23**)   
+
 ## Support
 Please use the [Image.sc Forum](https://forum.image.sc/tag/deepliif) for discussion and questions related to DeepLIIF.
 
@@ -369,7 +369,7 @@ and is available for non-commercial academic purposes.
 * This code is inspired by [CycleGAN and pix2pix in PyTorch](https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix).
 
 ## Reference
-If you find our work useful in your research or if you use parts of this code, please cite our paper:
+If you find our work useful in your research or if you use parts of this code or our released dataset, please cite the following papers:
 ```
 @article{ghahremani2022deep,
   title={Deep learning-inferred multiplex immunofluorescence for immunohistochemical image quantification},
@@ -390,4 +390,18 @@ If you find our work useful in your research or if you use parts of this code, p
   year={2022}
 }
 
+@article{ghahremani2023deepliifdataset,
+  title={An AI-Ready Multiplex Staining Dataset for Reproducible and Accurate Characterization of Tumor Immune Microenvironment},
+  author={Ghahremani, Parmida and Marino, Joseph and Hernandez-Prera, Juan and V. de la Iglesia, Janis and JC Slebos, Robbert and H. Chung, Christine and Nadeem, Saad},
+  journal={International Conference on Medical Image Computing and Computer-Assisted Intervention (MICCAI)},
+  year={2023}
+}
+
+@article{nadeem2023ki67validationMTC,
+  author = {Nadeem, Saad and Hanna, Matthew G and Viswanathan, Kartik and Marino, Joseph and Ahadi, Mahsa and Alzumaili, Bayan and Bani, Mohamed-Amine and Chiarucci, Federico and Chou, Angela and De Leo, Antonio and Fuchs, Talia L and Lubin, Daniel J and Luxford, Catherine and Magliocca, Kelly and Martinez, Germán and Shi, Qiuying and Sidhu, Stan and Al Ghuzlan, Abir and Gill, Anthony J and Tallini, Giovanni and Ghossein, Ronald and Xu, Bin},
+  title = {Ki67 proliferation index in medullary thyroid carcinoma: a comparative study of multiple counting methods and validation of image analysis and deep learning platforms},
+  journal = {Histopathology},
+  year = {2023},
+  doi = {https://doi.org/10.1111/his.15048}
+}
 ```

{deepliif-1.1.6 → deepliif-1.1.8}/README.md

@@ -5,20 +5,18 @@
     <img src="./images/DeepLIIF_logo.png" width="50%">
     <h3 align="center"><strong>Deep-Learning Inferred Multiplex Immunofluorescence for Immunohistochemical Image Quantification</strong></h3>
     <p align="center">
-    <a href="https://doi.org/10.1101/2021.05.01.442219">Journal Preprint</a>
+    <a href="https://rdcu.be/cKSBz">Nature MI'22</a>
     |
-    <a href="https://rdcu.be/cKSBz">Journal Link</a>
+    <a href="https://openaccess.thecvf.com/content/CVPR2022/html/Ghahremani_DeepLIIF_An_Online_Platform_for_Quantification_of_Clinical_Pathology_Slides_CVPR_2022_paper.html">CVPR'22</a>
     |
-    <a href="https://openaccess.thecvf.com/content/CVPR2022/html/Ghahremani_DeepLIIF_An_Online_Platform_for_Quantification_of_Clinical_Pathology_Slides_CVPR_2022_paper.html">CVPR Link</a>
+    <a href="https://arxiv.org/abs/2305.16465">MICCAI'23</a>
+    |
+    <a href="https://onlinelibrary.wiley.com/share/author/4AEBAGEHSZE9GDP3H8MN?target=10.1111/his.15048">Histopathology'23</a>
     |
     <a href="https://deepliif.org/">Cloud Deployment</a>
     |
     <a href="https://nadeemlab.github.io/DeepLIIF/">Documentation</a>
     |
-    <a href="#docker">Docker</a>
-    |
-    <a href="https://github.com/nadeemlab/DeepLIIF/tree/main/ImageJ_Plugin">ImageJ Plugin</a>
-    |
     <a href="#support">Support</a>
   </p>
 </p>
@@ -210,8 +208,7 @@ on how to deploy the model with Torchserve and for an example of how to run the
 We provide a Dockerfile that can be used to run the DeepLIIF models inside a container.
 First, you need to install the [Docker Engine](https://docs.docker.com/engine/install/ubuntu/).
 After installing the Docker, you need to follow these steps:
-* Download the pretrained model and place them in DeepLIIF/checkpoints/DeepLIIF_Latest_Model.
-* Change XXX of the **WORKDIR** line in the **DockerFile** to the directory containing the DeepLIIF project. 
+* Download the pretrained model [here](https://zenodo.org/record/4751737#.YKRTS0NKhH4) and place them in DeepLIIF/model-server/DeepLIIF_Latest_Model.
 * To create a docker image from the docker file:
 ```
 docker build -t cuda/deepliif .
@@ -220,7 +217,7 @@ The image is then used as a base. You can copy and use it to run an application.
 environment in which to run, referred to as a container.
 * To create and run a container:
 ```
- docker run -it -v `pwd`:`pwd` -w `pwd` cuda/deepliif deepliif test --input-dir Sample_Large_Tissues
+ docker run -it -v `pwd`:`pwd` -w `pwd` cuda/deepliif deepliif test --input-dir Sample_Large_Tissues --tile-size 512
 ```
 When you run a container from the image, the `deepliif` CLI will be available.
 You can easily run any CLI command in the activated environment and copy the results from the docker container to the host.
@@ -345,6 +342,9 @@ for the same slide (de novo staining) and would like to contribute that data for
 co-registration, whole-cell multiplex segmentation via [ImPartial](https://github.com/nadeemlab/ImPartial), train the 
 DeepLIIF model and release back to the community with full credit to the contributors.
 
+- [x] **Memorial Sloan Kettering Cancer Center** [AI-ready immunohistochemistry and multiplex immunofluorescence dataset](https://zenodo.org/record/4751737#.YKRTS0NKhH4) for breast, lung, and bladder cancers (**Nature Machine Intelligence'22**)
+- [x] **Moffitt Cancer Center** [AI-ready multiplex immunofluorescence and multiplex immunohistochemistry dataset](https://wiki.cancerimagingarchive.net/pages/viewpage.action?pageId=70226184) for head-and-neck squamous cell carcinoma (**MICCAI'23**)   
+
 ## Support
 Please use the [Image.sc Forum](https://forum.image.sc/tag/deepliif) for discussion and questions related to DeepLIIF.
 
@@ -358,7 +358,7 @@ and is available for non-commercial academic purposes.
 * This code is inspired by [CycleGAN and pix2pix in PyTorch](https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix).
 
 ## Reference
-If you find our work useful in your research or if you use parts of this code, please cite our paper:
+If you find our work useful in your research or if you use parts of this code or our released dataset, please cite the following papers:
 ```
 @article{ghahremani2022deep,
   title={Deep learning-inferred multiplex immunofluorescence for immunohistochemical image quantification},
@@ -379,4 +379,18 @@ If you find our work useful in your research or if you use parts of this code, p
   year={2022}
 }
 
+@article{ghahremani2023deepliifdataset,
+  title={An AI-Ready Multiplex Staining Dataset for Reproducible and Accurate Characterization of Tumor Immune Microenvironment},
+  author={Ghahremani, Parmida and Marino, Joseph and Hernandez-Prera, Juan and V. de la Iglesia, Janis and JC Slebos, Robbert and H. Chung, Christine and Nadeem, Saad},
+  journal={International Conference on Medical Image Computing and Computer-Assisted Intervention (MICCAI)},
+  year={2023}
+}
+
+@article{nadeem2023ki67validationMTC,
+  author = {Nadeem, Saad and Hanna, Matthew G and Viswanathan, Kartik and Marino, Joseph and Ahadi, Mahsa and Alzumaili, Bayan and Bani, Mohamed-Amine and Chiarucci, Federico and Chou, Angela and De Leo, Antonio and Fuchs, Talia L and Lubin, Daniel J and Luxford, Catherine and Magliocca, Kelly and Martinez, Germán and Shi, Qiuying and Sidhu, Stan and Al Ghuzlan, Abir and Gill, Anthony J and Tallini, Giovanni and Ghossein, Ronald and Xu, Bin},
+  title = {Ki67 proliferation index in medullary thyroid carcinoma: a comparative study of multiple counting methods and validation of image analysis and deep learning platforms},
+  journal = {Histopathology},
+  year = {2023},
+  doi = {https://doi.org/10.1111/his.15048}
+}
 ```

{deepliif-1.1.6 → deepliif-1.1.8}/cli.py

@@ -10,10 +10,11 @@ import numpy as np
 from PIL import Image
 
 from deepliif.data import create_dataset, transform
-from deepliif.models import inference, postprocess, compute_overlap, init_nets, DeepLIIFModel, infer_modalities, infer_results_for_wsi
+from deepliif.models import init_nets, infer_modalities, infer_results_for_wsi, create_model
 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
 
 import torch.distributed as dist
 
@@ -74,12 +75,13 @@ def print_options(opt):
     print(message)
 
     # save to the disk
-    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 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()
@@ -95,8 +97,9 @@ def cli():
               help='name of the experiment. It decides where to store samples and models')
 @click.option('--gpu-ids', type=int, multiple=True, help='gpu-ids 0 gpu-ids 1 or gpu-ids -1 for CPU')
 @click.option('--checkpoints-dir', default='./checkpoints', help='models are saved here')
-@click.option('--targets-no', default=5, help='number of targets')
+@click.option('--modalities-no', default=4, type=int, help='number of targets')
 # model parameters
+@click.option('--model', default='DeepLIIF', help='name of model class')
 @click.option('--input-nc', default=3, help='# of input image channels: 3 for RGB and 1 for grayscale')
 @click.option('--output-nc', default=3, help='# of output image channels: 3 for RGB and 1 for grayscale')
 @click.option('--ngf', default=64, help='# of gen filters in the last conv layer')
@@ -112,7 +115,6 @@ def cli():
 @click.option('--init-type', default='normal',
               help='network initialization [normal | xavier | kaiming | orthogonal]')
 @click.option('--init-gain', default=0.02, help='scaling factor for normal, xavier and orthogonal.')
-@click.option('--padding-type', default='reflect', help='network padding type.')
 @click.option('--no-dropout', is_flag=True, help='no dropout for the generator')
 # dataset parameters
 @click.option('--direction', default='AtoB', help='AtoB or BtoA')
@@ -175,19 +177,30 @@ def cli():
 @click.option('--save-by-iter', is_flag=True, help='whether saves model by iteration')
 @click.option('--remote', type=bool, default=False, help='whether isolate visdom checkpoints or not; if False, you can run a separate visdom server anywhere that consumes the checkpoints')
 @click.option('--remote-transfer-cmd', type=str, default=None, help='module and function to be used to transfer remote files to target storage location, for example mymodule.myfunction')
-@click.option('--dataset_mode', type=str, default='aligned',
+@click.option('--dataset-mode', type=str, default='aligned',
               help='chooses how datasets are loaded. [unaligned | aligned | single | colorization]')
 @click.option('--padding', type=str, default='zero',
               help='chooses the type of padding used by resnet generator. [reflect | zero]')
 @click.option('--local-rank', type=int, default=None, help='placeholder argument for torchrun, no need for manual setup')
 @click.option('--seed', type=int, default=None, help='basic seed to be used for deterministic training, default to None (non-deterministic)')
-def train(dataroot, name, gpu_ids, checkpoints_dir, targets_no, input_nc, output_nc, ngf, ndf, net_d, net_g,
-          n_layers_d, norm, init_type, init_gain, padding_type, no_dropout, direction, serial_batches, num_threads,
+# DeepLIIFExt params
+@click.option('--seg-gen', type=bool, default=True, help='True (Translation and Segmentation), False (Only Translation).')
+@click.option('--net-ds', type=str, default='n_layers',
+              help='specify discriminator architecture for segmentation task [basic | n_layers | pixel]. The basic model is a 70x70 PatchGAN. n_layers allows you to specify the layers in the discriminator')
+@click.option('--net-gs', type=str, default='unet_512',
+              help='specify generator architecture for segmentation task [resnet_9blocks | resnet_6blocks | unet_512 | unet_256 | unet_128]')
+@click.option('--gan-mode', type=str, default='vanilla',
+              help='the type of GAN objective for translation task. [vanilla| lsgan | wgangp]. vanilla GAN loss is the cross-entropy objective used in the original GAN paper.')
+@click.option('--gan-mode-s', type=str, default='lsgan',
+              help='the type of GAN objective for segmentation task. [vanilla| lsgan | wgangp]. vanilla GAN loss is the cross-entropy objective used in the original GAN paper.')
+def train(dataroot, name, gpu_ids, checkpoints_dir, input_nc, output_nc, ngf, ndf, net_d, net_g,
+          n_layers_d, norm, init_type, init_gain, no_dropout, direction, serial_batches, num_threads,
           batch_size, load_size, crop_size, max_dataset_size, preprocess, no_flip, display_winsize, epoch, load_iter,
           verbose, lambda_l1, is_train, display_freq, display_ncols, display_id, display_server, display_env,
           display_port, update_html_freq, print_freq, no_html, save_latest_freq, save_epoch_freq, save_by_iter,
           continue_train, epoch_count, phase, lr_policy, n_epochs, n_epochs_decay, beta1, lr, lr_decay_iters,
-          remote, local_rank, remote_transfer_cmd, seed, dataset_mode, padding):
+          remote, local_rank, remote_transfer_cmd, seed, dataset_mode, padding, model, 
+          modalities_no, seg_gen, net_ds, net_gs, gan_mode, gan_mode_s):
     """General-purpose training script for multi-task image-to-image translation.
 
     This script works for various models (with option '--model': e.g., DeepLIIF) and
@@ -199,6 +212,7 @@ def train(dataroot, name, gpu_ids, checkpoints_dir, targets_no, input_nc, output
     plot, and save models.The script supports continue/resume training.
     Use '--continue_train' to resume your previous training.
     """
+    d_params = locals()
 
     if gpu_ids and gpu_ids[0] == -1:
         gpu_ids = []
@@ -224,26 +238,21 @@ def train(dataroot, name, gpu_ids, checkpoints_dir, targets_no, input_nc, output
         flag_deterministic = set_seed(seed)
 
     if flag_deterministic:
-        padding_type = 'zero'
+        d_params['padding'] = 'zero'
         print('padding type is forced to zero padding, because neither refection pad2d or replication pad2d has a deterministic implementation')
 
     # create a dataset given dataset_mode and other options
     # dataset = AlignedDataset(opt)
 
-    opt = Options(dataroot, name, gpu_ids, checkpoints_dir, targets_no, input_nc, output_nc, ngf, ndf, net_d, net_g,
-                  n_layers_d, norm, init_type, init_gain, no_dropout, direction, serial_batches, num_threads,
-                  batch_size, load_size, crop_size, max_dataset_size, preprocess, no_flip, display_winsize, epoch,
-                  load_iter, verbose, lambda_l1, is_train, display_freq, display_ncols, display_id, display_server,
-                  display_env, display_port, update_html_freq, print_freq, no_html, save_latest_freq, save_epoch_freq,
-                  save_by_iter, continue_train, epoch_count, phase, lr_policy, n_epochs, n_epochs_decay, beta1,
-                  lr, lr_decay_iters, remote, remote_transfer_cmd, dataset_mode, padding)
+    opt = Options(d_params=d_params)
     print_options(opt)
+    
     dataset = create_dataset(opt)
     # get the number of images in the dataset.
     click.echo('The number of training images = %d' % len(dataset))
 
     # create a model given model and other options
-    model = DeepLIIFModel(opt)
+    model = create_model(opt)
     # regular setup: load and print networks; create schedulers
     model.setup(opt)
 
@@ -461,18 +470,26 @@ def trainlaunch(**kwargs):
 @cli.command()
 @click.option('--models-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('--verbose', default=0, type=int,help='saves results here.')
-def serialize(models_dir, output_dir, device, verbose):
+def serialize(models_dir, output_dir, tile_size, device, verbose):
     """Serialize DeepLIIF models using Torchscript
     """
+    if tile_size is None:
+        tile_size = 512
     output_dir = output_dir or models_dir
     ensure_exists(output_dir)
-
-    sample = transform(Image.new('RGB', (512, 512)))
+    
+    # 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')
+    
+    sample = transform(Image.new('RGB', (tile_size, tile_size)))
     
     with click.progressbar(
-            init_nets(models_dir, eager_mode=True).items(),
+            init_nets(models_dir, eager_mode=True, phase='test').items(),
             label='Tracing nets',
             item_show_func=lambda n: n[0] if n else n
     ) as bar:
@@ -491,8 +508,8 @@ def serialize(models_dir, output_dir, 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)
-    models_serialized = init_nets(output_dir,eager_mode=False)
+    models_original = init_nets(models_dir,eager_mode=True,phase='test')
+    models_serialized = init_nets(output_dir,eager_mode=False,phase='test')
     if device == 'gpu':
         sample = sample.cuda()
     else:
@@ -513,13 +530,14 @@ def serialize(models_dir, output_dir, device, verbose):
 @click.option('--output-dir', help='saves results here.')
 @click.option('--tile-size', default=None, help='tile size')
 @click.option('--model-dir', default='./model-server/DeepLIIF_Latest_Model/', help='load models from here.')
+@click.option('--gpu-ids', type=int, multiple=True, help='gpu-ids 0 gpu-ids 1 or gpu-ids -1 for CPU')
 @click.option('--region-size', default=20000, help='Due to limits in the resources, the whole slide image cannot be processed in whole.'
                                                    'So the WSI image is read region by region. '
                                                    'This parameter specifies the size each region to be read into GPU for inferrence.')
 @click.option('--eager-mode', is_flag=True, help='use eager mode (loading original models, otherwise serialized ones)')
 @click.option('--color-dapi', is_flag=True, help='color dapi image to produce the same coloring as in the paper')
 @click.option('--color-marker', is_flag=True, help='color marker image to produce the same coloring as in the paper')
-def test(input_dir, output_dir, tile_size, model_dir, region_size, eager_mode,
+def test(input_dir, output_dir, tile_size, model_dir, gpu_ids, region_size, eager_mode,
          color_dapi, color_marker):
     
     """Test trained models
@@ -528,6 +546,29 @@ def test(input_dir, output_dir, tile_size, model_dir, region_size, eager_mode,
     ensure_exists(output_dir)
 
     image_files = [fn for fn in os.listdir(input_dir) if allowed_file(fn)]
+    files = os.listdir(model_dir)
+    assert 'train_opt.txt' in files, f'file train_opt.txt is missing from model directory {model_dir}'
+    opt = Options(path_file=os.path.join(model_dir,'train_opt.txt'), mode='test')
+    opt.use_dp = False
+    
+    number_of_gpus_all = torch.cuda.device_count()
+    if number_of_gpus_all < len(gpu_ids) and -1 not in gpu_ids:
+        number_of_gpus = 0
+        gpu_ids = [-1]
+        print(f'Specified to use GPU {opt.gpu_ids} for inference, but there are only {number_of_gpus_all} GPU devices. Switched to CPU inference.')
+
+    if len(gpu_ids) > 0 and gpu_ids[0] == -1:
+        gpu_ids = []
+    elif len(gpu_ids) == 0:
+        gpu_ids = list(range(number_of_gpus_all))
+    
+    opt.gpu_ids = gpu_ids # overwrite gpu_ids; for test command, default gpu_ids at first is [] which will be translated to a list of all gpus
+    
+    # fix opt from old settings
+    if not hasattr(opt,'modalities_no') and hasattr(opt,'targets_no'):
+        opt.modalities_no = opt.targets_no - 1
+        del opt.targets_no
+    print_options(opt)
 
     with click.progressbar(
             image_files,
@@ -541,7 +582,7 @@ def test(input_dir, output_dir, tile_size, model_dir, region_size, eager_mode,
                 print(time.time() - start_time)
             else:
                 img = Image.open(os.path.join(input_dir, filename)).convert('RGB')
-                images, scoring = infer_modalities(img, tile_size, model_dir, eager_mode, color_dapi, color_marker)
+                images, scoring = infer_modalities(img, tile_size, model_dir, eager_mode, color_dapi, color_marker, opt)
 
                 for name, i in images.items():
                     i.save(os.path.join(
@@ -634,7 +675,8 @@ class CPU_Unpickler(pickle.Unpickler):
 
 @cli.command()
 @click.option('--pickle-dir', required=True, help='directory where the pickled snapshots are stored')
-def visualize(pickle_dir):
+@click.option('--display-env', default = None, help='window name; overwrite the display-env opt from the saved pickle file')
+def visualize(pickle_dir, display_env):
 
     path_init = os.path.join(pickle_dir,'opt.pickle')
     print(f'waiting for initialization signal from {path_init}')
@@ -643,6 +685,8 @@ def visualize(pickle_dir):
 
     params_opt = pickle.load(open(path_init,'rb'))
     params_opt.remote = False
+    if display_env is not None:
+        params_opt.display_env = display_env
     visualizer = Visualizer(params_opt)   # create a visualizer that display/save images and plots
 
     paths_plot = {'display_current_results':os.path.join(pickle_dir,'display_current_results.pickle'),
@@ -666,77 +710,7 @@ def visualize(pickle_dir):
         time.sleep(10)
 
 
-class Options:
-    def __init__(self, dataroot, name, gpu_ids, checkpoints_dir, targets_no, input_nc, output_nc, ngf, ndf, net_d,
-                 net_g, n_layers_d, norm, init_type, init_gain, no_dropout, direction, serial_batches, num_threads,
-                 batch_size, load_size, crop_size, max_dataset_size, preprocess, no_flip, display_winsize, epoch,
-                 load_iter, verbose, lambda_l1, is_train, display_freq, display_ncols, display_id, display_server, display_env,
-                 display_port, update_html_freq, print_freq, no_html, save_latest_freq, save_epoch_freq, save_by_iter,
-                 continue_train, epoch_count, phase, lr_policy, n_epochs, n_epochs_decay, beta1, lr, lr_decay_iters,
-                 remote, remote_transfer_cmd, dataset_mode, padding):
-        self.dataroot = dataroot
-        self.name = name
-        self.gpu_ids = gpu_ids
-        self.checkpoints_dir = checkpoints_dir
-        self.targets_no = targets_no
-        self.input_nc = input_nc
-        self.output_nc = output_nc
-        self.ngf = ngf
-        self.ndf = ndf
-        self.net_d = net_d
-        self.net_g = net_g
-        self.n_layers_d = n_layers_d
-        self.norm = norm
-        self.init_type = init_type
-        self.init_gain = init_gain
-        self.no_dropout = no_dropout
-        self.direction = direction
-        self.serial_batches = serial_batches
-        self.num_threads = num_threads
-        self.batch_size = batch_size
-        self.load_size = load_size
-        self.crop_size = crop_size
-        self.max_dataset_size = max_dataset_size
-        self.preprocess = preprocess
-        self.no_flip = no_flip
-        self.display_winsize = display_winsize
-        self.epoch = epoch
-        self.load_iter = load_iter
-        self.verbose = verbose
-        self.lambda_l1 = lambda_l1
-        self.is_train = is_train
-        self.display_freq = display_freq
-        self.display_ncols = display_ncols
-        self.display_id = display_id
-        self.display_server = display_server
-        self.display_env = display_env
-        self.display_port = display_port
-        self.update_html_freq = update_html_freq
-        self.print_freq = print_freq
-        self.no_html = no_html
-        self.save_latest_freq = save_latest_freq
-        self.save_epoch_freq = save_epoch_freq
-        self.save_by_iter = save_by_iter
-        self.continue_train = continue_train
-        self.epoch_count = epoch_count
-        self.phase = phase
-        self.lr_policy = lr_policy
-        self.n_epochs = n_epochs
-        self.n_epochs_decay = n_epochs_decay
-        self.beta1 = beta1
-        self.lr = lr
-        self.lr_decay_iters = lr_decay_iters
-        self.dataset_mode = dataset_mode
-        self.padding = padding
-        self.remote_transfer_cmd = remote_transfer_cmd
-
-        self.isTrain = True
-        self.netG = 'resnet_9blocks'
-        self.netD = 'n_layers'
-        self.n_layers_D = 4
-        self.lambda_L1 = 100
-        self.lambda_feat = 100
-        self.remote = remote
+
 
 
 if __name__ == '__main__':

{deepliif-1.1.6 → deepliif-1.1.8}/deepliif/data/aligned_dataset.py

@@ -25,9 +25,11 @@ class AlignedDataset(BaseDataset):
         self.input_nc = opt.output_nc if opt.direction == 'BtoA' else opt.input_nc
         self.output_nc = opt.input_nc if opt.direction == 'BtoA' else opt.output_nc
         self.no_flip = opt.no_flip
-        self.targets_no = opt.targets_no
+        self.modalities_no = opt.modalities_no
+        self.seg_gen = opt.seg_gen
         self.load_size = opt.load_size
         self.crop_size = opt.crop_size
+        self.model = opt.model
 
     def __getitem__(self, index):
         """Return a data point and its metadata information.
@@ -46,7 +48,13 @@ class AlignedDataset(BaseDataset):
         AB = Image.open(AB_path).convert('RGB')
         # split AB image into A and B
         w, h = AB.size
-        w2 = int(w / (self.targets_no + 1))
+        if self.model == 'DeepLIIF':
+            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   
+        else:
+            raise Exception(f'model class {self.model} does not have corresponding implementation in deepliif/data/aligned_dataset.py')
+        w2 = int(w / num_img)
         A = AB.crop((0, 0, w2, h))
 
         # apply the same transform to both A and B
@@ -56,12 +64,30 @@ class AlignedDataset(BaseDataset):
 
         A = A_transform(A)
         B_Array = []
-        for i in range(1, self.targets_no + 1):
-            B = AB.crop((w2 * i, 0, w2 * (i + 1), h))
-            B = B_transform(B)
-            B_Array.append(B)
+        if self.model == 'DeepLIIF':
+            for i in range(1, num_img):
+                B = AB.crop((w2 * i, 0, w2 * (i + 1), h))
+                B = B_transform(B)
+                B_Array.append(B)
 
-        return {'A': A, 'B': B_Array, 'A_paths': AB_path, 'B_paths': AB_path}
+            return {'A': A, 'B': B_Array, 'A_paths': AB_path, 'B_paths': AB_path}
+        elif self.model == 'DeepLIIFExt':
+            for i in range(1, self.modalities_no + 1):
+                B = AB.crop((w2 * i, 0, w2 * (i + 1), h))
+                B = B_transform(B)
+                B_Array.append(B)
+            
+            BS_Array = []
+            if self.seg_gen:
+                for i in range(self.modalities_no + 1, self.modalities_no * 2 + 1):
+                    BS = AB.crop((w2 * i, 0, w2 * (i + 1), h))
+                    BS = B_transform(BS)
+                    BS_Array.append(BS)
+
+            return {'A': A, 'B': B_Array, 'BS': BS_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')
+        
 
     def __len__(self):
         """Return the total number of images in the dataset."""