Merge pull request #16 from EIDOSLAB/backends

Backends

Author: carloalbertobarbano

.github/workflows/tests.yml

@@ -19,7 +19,7 @@ jobs:
           python-version: 3.6
 
       - name: Install dependencies
-        run: pip install wheel setuptools torch tensorflow numpy
+        run: pip install wheel setuptools
 
       - name: Build wheel
         run: python setup.py bdist_wheel
@@ -46,20 +46,82 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
 
-      - name: Install dependencies
-        run: pip install wheel setuptools torch tensorflow numpy
+      - name: Download artifact
+        uses: actions/download-artifact@master
+        with:
+          name: "Python wheel"
+
+      - name: Install deps and wheel
+        run: |
+          pip install tensorflow torch
+          pip install --find-links=${{github.workspace}} torchstain
 
       - name: Install test dependencies
-        run: pip install opencv-python matplotlib torchvision scikit-image pytest
+        run: pip install opencv-python torchvision scikit-image pytest
+
+      - name: Run tests
+        run: |
+          pytest -v tests/test_utils.py
+          pytest -v tests/test_normalizers.py
+
+  test-tf:
+    needs: build
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ windows-2019, ubuntu-18.04, macos-11 ]
+        python-version: [ 3.7 ]
+
+    steps:
+      - uses: actions/checkout@v1
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
 
       - name: Download artifact
         uses: actions/download-artifact@master
         with:
           name: "Python wheel"
 
-      - name: Install wheel
-        run: pip install --find-links=${{github.workspace}} torchstain
+      - name: Install deps and wheel
+        run: |
+          pip install tensorflow
+          pip install --find-links=${{github.workspace}} torchstain
+
+      - name: Install test dependencies
+        run: pip install opencv-python scikit-image pytest
 
       - name: Run tests
+        run: pytest -v tests/test_tf_normalizer.py
+
+  test-torch:
+    needs: build
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ windows-2019, ubuntu-18.04, macos-11 ]
+        python-version: [ 3.7 ]
+
+    steps:
+      - uses: actions/checkout@v1
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Download artifact
+        uses: actions/download-artifact@master
+        with:
+          name: "Python wheel"
+
+      - name: Install deps and wheel wheel
         run: |
-          pytest -v tests
+          pip install torch
+          pip install --find-links=${{github.workspace}} torchstain
+
+      - name: Install test dependencies
+        run: pip install opencv-python torchvision scikit-image pytest
+
+      - name: Run tests
+        run: pytest -v tests/test_torch_normalizer.py

README.md

@@ -4,15 +4,15 @@
 [![tests](https://github.com/EIDOSLAB/torchstain/workflows/tests/badge.svg)](https://github.com/EIDOSLAB/torchstain/actions)
 [![Pip Downloads](https://img.shields.io/pypi/dm/torchstain?label=pip%20downloads&logo=python)](https://pypi.org/project/torchstain/)
 
-Pytorch-compatible normalization tools for histopathological images.
+GPU-accelerated stain normalization tools for histopathological images. Compatible with PyTorch, TensorFlow, and Numpy.
 Normalization algorithms currently implemented:
 
 - Macenko et al. [\[1\]](#reference) (ported from [numpy implementation](https://github.com/schaugf/HEnorm_python))
 
 ## Installation
 
 ```bash
-pip3 install torchstain
+pip install torchstain
 ```
 
 ## Example Usage

example.py

@@ -10,18 +10,18 @@
 target = cv2.resize(cv2.cvtColor(cv2.imread("./data/target.png"), cv2.COLOR_BGR2RGB), (size, size))
 to_transform = cv2.resize(cv2.cvtColor(cv2.imread("./data/source.png"), cv2.COLOR_BGR2RGB), (size, size))
 
-normalizer = torchstain.MacenkoNormalizer(backend='numpy')
+normalizer = torchstain.normalizers.MacenkoNormalizer(backend='numpy')
 normalizer.fit(target)
 
 T = transforms.Compose([
     transforms.ToTensor(),
     transforms.Lambda(lambda x: x*255)
 ])
 
-torch_normalizer = torchstain.MacenkoNormalizer(backend='torch')
+torch_normalizer = torchstain.normalizers.MacenkoNormalizer(backend='torch')
 torch_normalizer.fit(T(target))
 
-tf_normalizer = torchstain.MacenkoNormalizer(backend='tensorflow')
+tf_normalizer = torchstain.normalizers.MacenkoNormalizer(backend='tensorflow')
 tf_normalizer.fit(T(target))
 
 t_to_transform = T(to_transform)

setup.py

@@ -1,5 +1,5 @@
 import pathlib
-from setuptools import setup, find_packages
+from setuptools import setup, find_packages, find_namespace_packages
 
 HERE = pathlib.Path(__file__).parent
 README = (HERE / "README.md").read_text()
@@ -17,10 +17,12 @@
     packages=find_packages(exclude=('tests')),
     zip_safe=False,
     install_requires=[
-        'torch',
-        'numpy',
-        'tensorflow'
+        'numpy'
     ],
+    extras_require={
+        "tf": ["tensorflow"],
+        "torch": ["torch"],
+    },
     classifiers=[
         'Development Status :: 4 - Beta',
         'Intended Audience :: Developers',

tests/test_normalizers.py

@@ -1,46 +1,45 @@
 import os
 import cv2
-import matplotlib.pyplot as plt
 import torchstain
 import torch
 from torchvision import transforms
 import time
 from skimage.metrics import structural_similarity as ssim
 import numpy as np
 
-
-size = 1024
-curr_file_path = os.path.dirname(os.path.realpath(__file__))
-target = cv2.resize(cv2.cvtColor(cv2.imread(os.path.join(curr_file_path, "../data/target.png")), cv2.COLOR_BGR2RGB), (size, size))
-to_transform = cv2.resize(cv2.cvtColor(cv2.imread(os.path.join(curr_file_path, "../data/source.png")), cv2.COLOR_BGR2RGB), (size, size))
-
-# setup preprocessing and preprocess image to be normalized
-T = transforms.Compose([
-    transforms.ToTensor(),
-    transforms.Lambda(lambda x: x*255)
-])
-t_to_transform = T(to_transform)
-
-# initialize normalizers for each backend and fit to target image
-normalizer = torchstain.MacenkoNormalizer(backend='numpy')
-normalizer.fit(target)
-
-torch_normalizer = torchstain.MacenkoNormalizer(backend='torch')
-torch_normalizer.fit(T(target))
-
-tf_normalizer = torchstain.MacenkoNormalizer(backend='tensorflow')
-tf_normalizer.fit(T(target))
-
-# transform
-result_numpy, _, _ = normalizer.normalize(I=to_transform, stains=True)
-result_torch, _, _ = torch_normalizer.normalize(I=t_to_transform, stains=True)
-result_tf, _, _ = tf_normalizer.normalize(I=t_to_transform, stains=True)
-
-# convert to numpy and set dtype
-result_numpy = result_numpy.astype("float32")
-result_torch = result_torch.numpy().astype("float32")
-result_tf = result_tf.numpy().astype("float32")
-
-# assess whether the normalized images are identical across backends
-np.testing.assert_almost_equal(ssim(result_numpy.flatten(), result_torch.flatten()), 1.0, decimal=4, verbose=True)
-np.testing.assert_almost_equal(ssim(result_numpy.flatten(), result_tf.flatten()), 1.0, decimal=4, verbose=True)
+def test_normalize_all():
+    size = 1024
+    curr_file_path = os.path.dirname(os.path.realpath(__file__))
+    target = cv2.resize(cv2.cvtColor(cv2.imread(os.path.join(curr_file_path, "../data/target.png")), cv2.COLOR_BGR2RGB), (size, size))
+    to_transform = cv2.resize(cv2.cvtColor(cv2.imread(os.path.join(curr_file_path, "../data/source.png")), cv2.COLOR_BGR2RGB), (size, size))
+
+    # setup preprocessing and preprocess image to be normalized
+    T = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Lambda(lambda x: x*255)
+    ])
+    t_to_transform = T(to_transform)
+
+    # initialize normalizers for each backend and fit to target image
+    normalizer = torchstain.normalizers.MacenkoNormalizer(backend='numpy')
+    normalizer.fit(target)
+
+    torch_normalizer = torchstain.normalizers.MacenkoNormalizer(backend='torch')
+    torch_normalizer.fit(T(target))
+
+    tf_normalizer = torchstain.normalizers.MacenkoNormalizer(backend='tensorflow')
+    tf_normalizer.fit(T(target))
+
+    # transform
+    result_numpy, _, _ = normalizer.normalize(I=to_transform, stains=True)
+    result_torch, _, _ = torch_normalizer.normalize(I=t_to_transform, stains=True)
+    result_tf, _, _ = tf_normalizer.normalize(I=t_to_transform, stains=True)
+
+    # convert to numpy and set dtype
+    result_numpy = result_numpy.astype("float32")
+    result_torch = result_torch.numpy().astype("float32")
+    result_tf = result_tf.numpy().astype("float32")
+
+    # assess whether the normalized images are identical across backends
+    np.testing.assert_almost_equal(ssim(result_numpy.flatten(), result_torch.flatten()), 1.0, decimal=4, verbose=True)
+    np.testing.assert_almost_equal(ssim(result_numpy.flatten(), result_tf.flatten()), 1.0, decimal=4, verbose=True)

tests/test_tf_normalizer.py

@@ -0,0 +1,35 @@
+import os
+import cv2
+import torchstain
+import tensorflow as tf
+import time
+from skimage.metrics import structural_similarity as ssim
+import numpy as np
+
+def test_normalize_tf():
+    size = 1024
+    curr_file_path = os.path.dirname(os.path.realpath(__file__))
+    target = cv2.resize(cv2.cvtColor(cv2.imread(os.path.join(curr_file_path, "../data/target.png")), cv2.COLOR_BGR2RGB), (size, size))
+    to_transform = cv2.resize(cv2.cvtColor(cv2.imread(os.path.join(curr_file_path, "../data/source.png")), cv2.COLOR_BGR2RGB), (size, size))
+
+    # setup preprocessing and preprocess image to be normalized
+    T = lambda x: tf.convert_to_tensor(np.moveaxis(x, -1, 0).astype("float32"))  #  * 255
+    t_to_transform = T(to_transform)
+
+    # initialize normalizers for each backend and fit to target image
+    normalizer = torchstain.normalizers.MacenkoNormalizer(backend='numpy')
+    normalizer.fit(target)
+
+    tf_normalizer = torchstain.normalizers.MacenkoNormalizer(backend='tensorflow')
+    tf_normalizer.fit(T(target))
+
+    # transform
+    result_numpy, _, _ = normalizer.normalize(I=to_transform, stains=True)
+    result_tf, _, _ = tf_normalizer.normalize(I=t_to_transform, stains=True)
+
+    # convert to numpy and set dtype
+    result_numpy = result_numpy.astype("float32")
+    result_tf = result_tf.numpy().astype("float32")
+
+    # assess whether the normalized images are identical across backends
+    np.testing.assert_almost_equal(ssim(result_numpy.flatten(), result_tf.flatten()), 1.0, decimal=4, verbose=True)

tests/test_torch_normalizer.py

@@ -0,0 +1,39 @@
+import os
+import cv2
+import torchstain
+import torch
+from torchvision import transforms
+import time
+from skimage.metrics import structural_similarity as ssim
+import numpy as np
+
+def test_normalize_torch():
+    size = 1024
+    curr_file_path = os.path.dirname(os.path.realpath(__file__))
+    target = cv2.resize(cv2.cvtColor(cv2.imread(os.path.join(curr_file_path, "../data/target.png")), cv2.COLOR_BGR2RGB), (size, size))
+    to_transform = cv2.resize(cv2.cvtColor(cv2.imread(os.path.join(curr_file_path, "../data/source.png")), cv2.COLOR_BGR2RGB), (size, size))
+
+    # setup preprocessing and preprocess image to be normalized
+    T = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Lambda(lambda x: x*255)
+    ])
+    t_to_transform = T(to_transform)
+
+    # initialize normalizers for each backend and fit to target image
+    normalizer = torchstain.normalizers.MacenkoNormalizer(backend='numpy')
+    normalizer.fit(target)
+
+    torch_normalizer = torchstain.normalizers.MacenkoNormalizer(backend='torch')
+    torch_normalizer.fit(T(target))
+
+    # transform
+    result_numpy, _, _ = normalizer.normalize(I=to_transform, stains=True)
+    result_torch, _, _ = torch_normalizer.normalize(I=t_to_transform, stains=True)
+
+    # convert to numpy and set dtype
+    result_numpy = result_numpy.astype("float32")
+    result_torch = result_torch.numpy().astype("float32")
+
+    # assess whether the normalized images are identical across backends
+    np.testing.assert_almost_equal(ssim(result_numpy.flatten(), result_torch.flatten()), 1.0, decimal=4, verbose=True)

tests/test_utils.py

@@ -1,19 +1,19 @@
 import torch
 import torchstain
+import torchstain.torch
 import numpy as np
 
-
 def test_cov():
     x = np.random.randn(10, 10)
     cov_np = np.cov(x)
-    cov_t = torchstain.utils.cov(torch.tensor(x))
+    cov_t = torchstain.torch.utils.cov(torch.tensor(x))
 
     np.testing.assert_almost_equal(cov_np, cov_t.numpy())
 
 def test_percentile():
     x = np.random.randn(10, 10)
     p = 20
-    p_np = np.percentile(x, p, method='nearest')
-    p_t = torchstain.utils.percentile(torch.tensor(x), p)
+    p_np = np.percentile(x, p, interpolation='nearest')
+    p_t = torchstain.torch.utils.percentile(torch.tensor(x), p)
 
     np.testing.assert_almost_equal(p_np, p_t)

torchstain/__init__.py

@@ -1,3 +1,3 @@
 __version__ = '1.1.0'
 
-from torchstain.normalizers.macenko_normalizer import MacenkoNormalizer
+from torchstain.base import normalizers

torchstain/base/__init__.py

@@ -0,0 +1 @@
+from torchstain.base import normalizers