deepliif 1.1.9__py3-none-any.whl → 1.1.11__py3-none-any.whl

deepliif/util/__init__.py

@@ -118,6 +118,211 @@ def stitch_tile(img, tile, tile_size, overlap_size, i, j):
     img.paste(tile, (i * tile_size, j * tile_size))
 
 
+class InferenceTiler:
+    """
+    Iterable class to tile image(s) and stitch result tiles together.
+
+    To perform inference on a large image, that image will need to be
+    tiled into smaller tiles that can be run individually and then
+    stitched back together. This class wraps the functionality as an
+    iterable object that can accept a single image or list of images
+    if multiple images are taken as input for inference.
+
+    An overlap size can be specified so that neighboring tiles will
+    overlap at the edges, helping to reduce seams or other artifacts
+    near the edge of a tile. Padding of a solid color around the
+    perimeter of the tile is also possible, if needed. The specified
+    tile size includes this overlap and pad sizes, so a tile size of
+    512 with an overlap size of 32 and pad size of 16 would have a
+    central area of 416 pixels that are stitched into the result image.
+
+    Example Usage
+    -------------
+    tiler = InferenceTiler(img, 512, 32)
+    for tile in tiler:
+        result_tiles = infer(tile)
+        tiler.stitch(result_tiles)
+    images = tiler.results()
+    """
+
+    def __init__(self, orig, tile_size, overlap_size=0, pad_size=0, pad_color=(255, 255, 255)):
+        """
+        Initialize for tiling an image or list of images.
+
+        Parameters
+        ----------
+        orig : Image | list(Image)
+            Original image or list of images to be tiled.
+        tile_size: int
+            Size (width and height) of the tiles to be generated.
+        overlap_size: int [default: 0]
+            Amount of overlap on each side of the tile.
+        pad_size: int [default: 0]
+            Amount of solid color padding around perimeter of tile.
+        pad_color: tuple(int, int, int) [default: (255,255,255)]
+            RGB color to use for padding.
+        """
+
+        if tile_size <= 0:
+            raise ValueError('InfereneTiler input tile_size must be positive and non-zero')
+        if overlap_size < 0:
+            raise ValueError('InfereneTiler input overlap_size must be positive or zero')
+        if pad_size < 0:
+            raise ValueError('InfereneTiler input pad_size must be positive or zero')
+
+        self.single_orig = not type(orig) is list
+        if self.single_orig:
+            orig = [orig]
+
+        for i in range(1, len(orig)):
+            if orig[i].size != orig[0].size:
+                raise ValueError('InferenceTiler input images do not have the same size.')
+        self.orig_width = orig[0].width
+        self.orig_height = orig[0].height
+
+        # patch size to extract from input image, which is then padded to tile size
+        patch_size = tile_size - (2 * pad_size)
+
+        # make sure width and height are both at least patch_size
+        if orig[0].width < patch_size:
+            for i in range(len(orig)):
+                while orig[i].width < patch_size:
+                    mirrored = ImageOps.mirror(orig[i])
+                    orig[i] = ImageOps.expand(orig[i], (0, 0, orig[i].width, 0))
+                    orig[i].paste(mirrored, (mirrored.width, 0))
+                orig[i] = orig[i].crop((0, 0, patch_size, orig[i].height))
+        if orig[0].height < patch_size:
+            for i in range(len(orig)):
+                while orig[i].height < patch_size:
+                    flipped = ImageOps.flip(orig[i])
+                    orig[i] = ImageOps.expand(orig[i], (0, 0, 0, orig[i].height))
+                    orig[i].paste(flipped, (0, flipped.height))
+                orig[i] = orig[i].crop((0, 0, orig[i].width, patch_size))
+        self.image_width = orig[0].width
+        self.image_height = orig[0].height
+
+        overlap_width = 0 if patch_size >= self.image_width else overlap_size
+        overlap_height = 0 if patch_size >= self.image_height else overlap_size
+        center_width = patch_size - (2 * overlap_width)
+        center_height = patch_size - (2 * overlap_height)
+        if center_width <= 0 or center_height <= 0:
+            raise ValueError('InferenceTiler combined overlap_size and pad_size are too large')
+
+        self.c0x = pad_size                               # crop offset for left of non-pad content in result tile
+        self.c0y = pad_size                               # crop offset for top of non-pad content in result tile
+        self.c1x = overlap_width + pad_size               # crop offset for left of center region in result tile
+        self.c1y = overlap_height + pad_size              # crop offset for top of center region in result tile
+        self.c2x = patch_size - overlap_width + pad_size  # crop offset for right of center region in result tile
+        self.c2y = patch_size - overlap_height + pad_size # crop offset for bottom of center region in result tile
+        self.c3x = patch_size + pad_size                  # crop offset for right of non-pad content in result tile
+        self.c3y = patch_size + pad_size                  # crop offset for bottom of non-pad content in result tile
+        self.p1x = overlap_width               # paste offset for left of center region w.r.t (x,y) coord
+        self.p1y = overlap_height              # paste offset for top of center region w.r.t (x,y) coord
+        self.p2x = patch_size - overlap_width  # paste offset for right of center region w.r.t (x,y) coord
+        self.p2y = patch_size - overlap_height # paste offset for bottom of center region w.r.t (x,y) coord
+
+        self.overlap_width = overlap_width
+        self.overlap_height = overlap_height
+        self.patch_size = patch_size
+        self.center_width = center_width
+        self.center_height = center_height
+
+        self.orig = orig
+        self.tile_size = tile_size
+        self.pad_size = pad_size
+        self.pad_color = pad_color
+        self.res = {}
+
+    def __iter__(self):
+        """
+        Generate the tiles as an iterable.
+
+        Tiles are created and iterated over from top left to bottom
+        right, going across the rows. The yielded tile(s) match the
+        type of the original input when initialized (either a single
+        image or a list of images in the same order as initialized).
+        The (x, y) coordinate of the current tile is maintained
+        internally for use in the stitch function.
+        """
+
+        for y in range(0, self.image_height, self.center_height):
+            for x in range(0, self.image_width, self.center_width):
+                if x + self.patch_size > self.image_width:
+                    x = self.image_width - self.patch_size
+                if y + self.patch_size > self.image_height:
+                    y = self.image_height - self.patch_size
+                self.x = x
+                self.y = y
+                tiles = [im.crop((x, y, x + self.patch_size, y + self.patch_size)) for im in self.orig]
+                if self.pad_size != 0:
+                    tiles = [ImageOps.expand(t, self.pad_size, self.pad_color) for t in tiles]
+                yield tiles[0] if self.single_orig else tiles
+
+    def stitch(self, result_tiles):
+        """
+        Stitch result tiles into the result images.
+
+        The key names for the dictionary of result tiles are used to
+        stitch each tile into its corresponding final image in the
+        results attribute. If a result image does not exist for a
+        result tile key name, then it will be created. The result tiles
+        are stitched at the location from which the list iterated tile
+        was extracted.
+
+        Parameters
+        ----------
+        result_tiles : dict(str: Image)
+            Dictionary of result tiles from the inference.
+        """
+
+        for k, tile in result_tiles.items():
+            if k not in self.res:
+                self.res[k] = Image.new('RGB', (self.image_width, self.image_height))
+            if tile.size != (self.tile_size, self.tile_size):
+                tile = tile.resize((self.tile_size, self.tile_size))
+            self.res[k].paste(tile.crop((self.c1x, self.c1y, self.c2x, self.c2y)), (self.x + self.p1x, self.y + self.p1y))
+
+            # top left corner
+            if self.x == 0 and self.y == 0:
+                self.res[k].paste(tile.crop((self.c0x, self.c0y, self.c1x, self.c1y)), (self.x, self.y))
+            # top row
+            if self.y == 0:
+                self.res[k].paste(tile.crop((self.c1x, self.c0y, self.c2x, self.c1y)), (self.x + self.p1x, self.y))
+            # top right corner
+            if self.x == self.image_width - self.patch_size and self.y == 0:
+                self.res[k].paste(tile.crop((self.c2x, self.c0y, self.c3x, self.c1y)), (self.x + self.p2x, self.y))
+            # left column
+            if self.x == 0:
+                self.res[k].paste(tile.crop((self.c0x, self.c1y, self.c1x, self.c2y)), (self.x, self.y + self.p1y))
+            # right column
+            if self.x == self.image_width - self.patch_size:
+                self.res[k].paste(tile.crop((self.c2x, self.c1y, self.c3x, self.c2y)), (self.x + self.p2x, self.y + self.p1y))
+            # bottom left corner
+            if self.x == 0 and self.y == self.image_height - self.patch_size:
+                self.res[k].paste(tile.crop((self.c0x, self.c2y, self.c1x, self.c3y)), (self.x, self.y + self.p2y))
+            # bottom row
+            if self.y == self.image_height - self.patch_size:
+                self.res[k].paste(tile.crop((self.c1x, self.c2y, self.c2x, self.c3y)), (self.x + self.p1x, self.y + self.p2y))
+            # bottom right corner
+            if self.x == self.image_width - self.patch_size and self.y == self.image_height - self.patch_size:
+                self.res[k].paste(tile.crop((self.c2x, self.c2y, self.c3x, self.c3y)), (self.x + self.p2x, self.y + self.p2y))
+
+    def results(self):
+        """
+        Return a dictionary of result images.
+
+        The keys for the result images are the same as those used for
+        the result tiles in the stitch function. This function should
+        only be called once, since the stitched images will be cropped
+        if the original image size was less than the patch size.
+        """
+
+        if self.orig_width != self.image_width or self.orig_height != self.image_height:
+            return {k: im.crop((0, 0, self.orig_width, self.orig_height)) for k, im in self.res.items()}
+        else:
+            return {k: im for k, im in self.res.items()}
+
+
 def calculate_background_mean_value(img):
     img = cv2.fastNlMeansDenoisingColored(np.array(img), None, 10, 10, 7, 21)
     img = np.array(img, dtype=float)
@@ -164,6 +369,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.9.dist-info → deepliif-1.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepliif
-Version: 1.1.9
+Version: 1.1.11
 Summary: DeepLIIF: Deep-Learning Inferred Multiplex Immunofluorescence for Immunohistochemical Image Quantification
 Home-page: https://github.com/nadeemlab/DeepLIIF
 Author: Parmida93
@@ -34,6 +34,8 @@ Requires-Dist: python-bioformats (>=4.0.6)
     |
     <a href="https://onlinelibrary.wiley.com/share/author/4AEBAGEHSZE9GDP3H8MN?target=10.1111/his.15048">Histopathology'23</a>
     |
+    <a href="https://arxiv.org/abs/2405.08169">MICCAI'24</a>
+    |
     <a href="https://deepliif.org/">Cloud Deployment</a>
     |
     <a href="https://nadeemlab.github.io/DeepLIIF/">Documentation</a>
@@ -61,6 +63,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 +137,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 +183,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 +192,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 +223,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
 ```
@@ -255,27 +262,161 @@ The plugin also supports submitting multiple ROIs at once:
 ## Cloud Deployment
 If you don't have access to GPU or appropriate hardware and don't want to install ImageJ, we have also created a [cloud-native DeepLIIF deployment](https://deepliif.org) with a user-friendly interface to upload images, visualize, interact, and download the final results.
 
-![DeepLIIF Website Demo](images/deepliif-website-demo-03.gif)
+![DeepLIIF Website Demo](images/deepliif-website-demo-04.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.
+
+  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.).
+
+  slim
+    If present, return only the refined segmentation result image.
+
+  nopost
+    If present, do not perform postprocessing (returns only inferred images).
+
+  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:
+
+```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]
 
-img (required)
-file: image to run the models on
+res = requests.post(
+    url='https://deepliif.org/api/infer',
+    files={
+        'img': open(f'{images_dir}/{filename}', 'rb'),
+    },
+    params={
+        'resolution': '40x',
+    },
+)
+
+data = res.json()
 
-resolution
-string: resolution used to scan the slide (10x, 20x, 40x), defaults to 40x 
+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))
+```
 
-pil
-boolean: if true, use PIL.Image.open() to load the image, instead of python-bioformats
+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:
 
-slim
-boolean: if true, return only the segmentation result image
+```
+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:
@@ -293,15 +434,20 @@ 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'),
+        'seg_img': open(f'{images_dir}/{root}_Seg.png', 'rb'),
+        'marker_img': open(f'{images_dir}/{root}_Marker.png', 'rb'),
     },
-    # optional param that can be 10x, 20x, or 40x (default)
     params={
-        'resolution': '40x'
-    }
+        'resolution': '40x',
+        'pil': True,
+        'size_thresh': 250,
+    },
 )
 
 data = res.json()
@@ -310,10 +456,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))
 ```
 
@@ -414,4 +561,11 @@ If you find our work useful in your research or if you use parts of this code or
   year = {2023},
   doi = {https://doi.org/10.1111/his.15048}
 }
+
+@article{zehra2024deepliifstitch,
+author = {Zehra, Talat and Marino, Joseph and Wang, Wendy and Frantsuzov, Grigoriy and Nadeem, Saad},
+title = {Rethinking Histology Slide Digitization Workflows for Low-Resource Settings},
+journal = {International Conference on Medical Image Computing and Computer-Assisted Intervention (MICCAI)},
+year = {2024}
+}
 ```

{deepliif-1.1.9.dist-info → deepliif-1.1.11.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=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=E2udWyU4eScFnvDO2qtwMeHRz4ihw8hhCoP666QBK4o,22674
+deepliif/models/SDG_model.py,sha256=xcZCTMNyJbcB78I1c8KtYVIB6OWL7WSMKdCxNemIzxs,9074
+deepliif/models/__init__.py,sha256=LWEyM7YwSoQ1TgRnsFk8O96xTf-QIxw5o_RexnECl_Q,28049
 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=bIa1Y1YQynvAoXux8ENAk_8Ykpfu9xxGByg-pgfGkK0,28090
 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.9.dist-info/LICENSE.md,sha256=HlZw_UPS6EtJimJ_Ci7xKh-S5Iubs0Z8y8E6EZ3ZNyE,956
-deepliif-1.1.9.dist-info/METADATA,sha256=CBgGs3wxeg1Hewt7lbAFUEH4Sbm5jV6jt4F3q59gvzM,25076
-deepliif-1.1.9.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-deepliif-1.1.9.dist-info/entry_points.txt,sha256=f70-10j2q68o_rDlsE3hspnv4ejlDnXwwGZ9JJ-3yF4,37
-deepliif-1.1.9.dist-info/top_level.txt,sha256=vLDK5YKmDz08E7PywuvEjAo7dM5rnIpsjR4c0ubQCnc,13
-deepliif-1.1.9.dist-info/RECORD,,
+deepliif-1.1.11.dist-info/LICENSE.md,sha256=HlZw_UPS6EtJimJ_Ci7xKh-S5Iubs0Z8y8E6EZ3ZNyE,956
+deepliif-1.1.11.dist-info/METADATA,sha256=3UtsAvCQz1osg0cBCnnLZVT1pvPdRxFbsaJ6B_yn_SI,31598
+deepliif-1.1.11.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+deepliif-1.1.11.dist-info/entry_points.txt,sha256=f70-10j2q68o_rDlsE3hspnv4ejlDnXwwGZ9JJ-3yF4,37
+deepliif-1.1.11.dist-info/top_level.txt,sha256=vLDK5YKmDz08E7PywuvEjAo7dM5rnIpsjR4c0ubQCnc,13
+deepliif-1.1.11.dist-info/RECORD,,