Merge pull request #105 from bioimage-io/fixed_shape_support

Fixed shape support

Author: FynnBe

bioimageio/core/prediction.py

@@ -295,7 +295,7 @@ def predict_with_tiling(prediction_pipeline: PredictionPipeline, inputs, tiling)
             ):
                 raise NotImplementedError("Tiling with a different output shape is not yet supported")
 
-            ref_input = named_inputs[output_spec.shape.reference_input]
+            ref_input = named_inputs[output_spec.shape.reference_tensor]
             ref_input_shape = dict(zip(ref_input.dims, ref_input.shape))
             output_shape = tuple(int(scale[ax] * ref_input_shape[ax] + 2 * offset[ax]) for ax in output_spec.axes)
         else:

bioimageio/core/prediction_pipeline/_prediction_pipeline.py

@@ -257,7 +257,7 @@ def create_prediction_pipeline(
         elif isinstance(out.shape, ImplicitOutputShape):
             named_output_shape.append(
                 NamedImplicitOutputShape(
-                    reference_input=out.shape.reference_input,
+                    reference_input=out.shape.reference_tensor,
                     scale=list(zip(out.axes, out.shape.scale)),
                     offset=list(zip(out.axes, out.shape.offset)),
                 )

bioimageio/core/resource_io/nodes.py

@@ -27,7 +27,7 @@ class URI(Node, raw_nodes.URI):
 
 
 @dataclass
-class ImplicitInputShape(Node, raw_nodes.ImplicitInputShape):
+class ParametrizedInputShape(Node, raw_nodes.ParametrizedInputShape):
     pass
 
 

tests/build_spec/test_build_spec.py

@@ -1,10 +1,8 @@
 import os
 
-import pytest
-
-import bioimageio.spec as spec
 from marshmallow import missing
 
+import bioimageio.spec as spec
 from bioimageio.core.resource_io.io_ import load_raw_resource_description
 
 
@@ -56,33 +54,27 @@ def _test_build_spec(path, weight_type, tensorflow_version=None):
     spec.model.schema.Model().dump(raw_model)
 
 
-@pytest.mark.skipif(pytest.skip_torch, reason="requires torch")
 def test_build_spec_pytorch(any_torch_model):
     _test_build_spec(any_torch_model, "pytorch_state_dict")
 
 
-@pytest.mark.skipif(pytest.skip_torch, reason="requires torch")
 def test_build_spec_torchscript(any_torchscript_model):
     _test_build_spec(any_torchscript_model, "pytorch_script")
 
 
-@pytest.mark.skipif(pytest.skip_onnx, reason="requires onnx")
 def test_build_spec_onnx(any_onnx_model):
     _test_build_spec(any_onnx_model, "onnx")
 
 
-@pytest.mark.skipif(pytest.skip_tensorflow or pytest.tf_major_version != 1, reason="requires tensorflow 1")
 def test_build_spec_keras(any_keras_model):
     _test_build_spec(any_keras_model, "keras_hdf5", tensorflow_version="1.12")  # todo: keras for tf 2??
 
 
-@pytest.mark.skipif(pytest.skip_tensorflow, reason="requires tensorflow")
 def test_build_spec_tf(any_tensorflow_model):
     _test_build_spec(
         any_tensorflow_model, "tensorflow_saved_model_bundle", tensorflow_version="1.12"
     )  # check tf version
 
 
-@pytest.mark.skipif(pytest.skip_tensorflow, reason="requires tensorflow")
 def test_build_spec_tfjs(any_tensorflow_js_model):
     _test_build_spec(any_tensorflow_js_model, "tensorflow_js", tensorflow_version="1.12")

tests/conftest.py

@@ -2,131 +2,152 @@
 from bioimageio.core import export_resource_package
 
 # test models for various frameworks
-torch_models = ["unet2d_nuclei_broad_model", "unet2d_multi_tensor"]
-torchscript_models = ["unet2d_nuclei_broad_model", "unet2d_multi_tensor"]
-onnx_models = ["unet2d_nuclei_broad_model", "unet2d_multi_tensor"]
+torch_models = ["unet2d_fixed_shape", "unet2d_multi_tensor", "unet2d_nuclei_broad_model"]
+torchscript_models = ["unet2d_multi_tensor", "unet2d_nuclei_broad_model"]
+onnx_models = ["unet2d_multi_tensor", "unet2d_nuclei_broad_model"]
 tensorflow1_models = ["FruNet_model"]
 tensorflow2_models = []
 keras_models = ["FruNet_model"]
 tensorflow_js_models = ["FruNet_model"]
 
 model_sources = {
+    "FruNet_model": "https://sandbox.zenodo.org/record/894498/files/rdf.yaml",
+    # "FruNet_model": "https://raw.githubusercontent.com/deepimagej/models/master/fru-net_sev_segmentation/model.yaml",
     "unet2d_nuclei_broad_model": (
         "https://raw.githubusercontent.com/bioimage-io/spec-bioimage-io/main/example_specs/models/"
         "unet2d_nuclei_broad/rdf.yaml"
     ),
+    "unet2d_fixed_shape": (
+        "https://raw.githubusercontent.com/bioimage-io/spec-bioimage-io/main/example_specs/models/"
+        "unet2d_fixed_shape/rdf.yaml"
+    ),
     "unet2d_multi_tensor": (
         "https://raw.githubusercontent.com/bioimage-io/spec-bioimage-io/main/example_specs/models/"
         "unet2d_multi_tensor/rdf.yaml"
     ),
-    "FruNet_model": "https://sandbox.zenodo.org/record/894498/files/rdf.yaml",
-    # "FruNet_model": "https://raw.githubusercontent.com/deepimagej/models/master/fru-net_sev_segmentation/model.yaml",
 }
 
-# set 'skip_<FRAMEWORK>' flags as global pytest variables,
-# to deselect tests that require frameworks not available in current env
-def pytest_configure():
-    try:
-        import torch
-    except ImportError:
-        torch = None
-    pytest.skip_torch = torch is None
-
-    try:
-        import onnxruntime
-    except ImportError:
-        onnxruntime = None
-    pytest.skip_onnx = onnxruntime is None
+try:
+    import torch
+except ImportError:
+    torch = None
+skip_torch = torch is None
+
+try:
+    import onnxruntime
+except ImportError:
+    onnxruntime = None
+skip_onnx = onnxruntime is None
+
+try:
+    import tensorflow
+
+    tf_major_version = int(tensorflow.__version__.split(".")[0])
+except ImportError:
+    tensorflow = None
+    tf_major_version = None
+
+skip_tensorflow = tensorflow is None
+skip_tensorflow = True  # todo: update FruNet and remove this
+skip_tensorflow_js = True  # todo: update FruNet and figure out how to test tensorflow_js weights in python
+
+try:
+    import keras
+except ImportError:
+    keras = None
+skip_keras = keras is None
+skip_keras = True  # FruNet requires update
+
+# load all model packages we need for testing
+load_model_packages = set()
+if not skip_torch:
+    load_model_packages |= set(torch_models + torchscript_models)
+
+if not skip_onnx:
+    load_model_packages |= set(onnx_models)
+
+if not skip_tensorflow:
+    load_model_packages |= set(keras_models)
+    load_model_packages |= set(tensorflow_js_models)
+    if tf_major_version == 1:
+        load_model_packages |= set(tensorflow1_models)
+    elif tf_major_version == 2:
+        load_model_packages |= set(tensorflow2_models)
 
-    try:
-        import tensorflow
-
-        pytest.tf_major_version = int(tensorflow.__version__.split(".")[0])
-    except ImportError:
-        tensorflow = None
-    pytest.skip_tensorflow = tensorflow is None
-    pytest.skip_tensorflow = True  # todo: update FruNet and remove this
-
-    try:
-        import keras
-    except ImportError:
-        keras = None
-    pytest.skip_keras = keras is None
-    pytest.skip_keras = True  # FruNet requires update
-
-    # load all model packages we need for testing
-    load_packages = {"unet2d_nuclei_broad_model"}  # always load unet2d_nuclei_broad_model
-    if not pytest.skip_torch:
-        load_packages |= set(torch_models + torchscript_models)
-
-    if not pytest.skip_onnx:
-        load_packages |= set(onnx_models)
-
-    if not pytest.skip_tensorflow:
-        load_packages |= set(keras_models)
-        load_packages |= set(tensorflow_js_models)
-        if pytest.tf_major_version == 1:
-            load_packages |= set(tensorflow1_models)
-        elif pytest.tf_major_version == 2:
-            load_packages |= set(tensorflow2_models)
-
-    pytest.model_packages = {name: export_resource_package(model_sources[name]) for name in load_packages}
 
+def pytest_configure():
 
-@pytest.fixture
-def unet2d_nuclei_broad_model():
-    return pytest.model_packages["unet2d_nuclei_broad_model"]
+    # explicit skip flags needed for some tests
+    pytest.skip_torch = skip_torch
+    pytest.skip_onnx = skip_onnx
 
+    # load all model packages used in tests
+    pytest.model_packages = {name: export_resource_package(model_sources[name]) for name in load_model_packages}
 
-@pytest.fixture
-def unet2d_multi_tensor():
-    return pytest.model_packages["unet2d_multi_tensor"]
 
+#
+# model groups of the form any_<weight format>_model that include all models providing a specific weight format
+#
 
-@pytest.fixture
-def FruNet_model():
-    return pytest.model_packages["FruNet_model"]
+# written as model group to automatically skip on missing torch
+@pytest.fixture(params=[] if skip_torch else ["unet2d_nuclei_broad_model"])
+def unet2d_nuclei_broad_model(request):
+    return pytest.model_packages[request.param]
 
 
-#
-# model groups
-#
+# written as model group to automatically skip on missing tensorflow 1
+@pytest.fixture(params=[] if skip_tensorflow or tf_major_version != 1 else ["FruNet_model"])
+def FruNet_model(request):
+    return pytest.model_packages[request.param]
 
 
-@pytest.fixture(params=torch_models)
+@pytest.fixture(params=[] if skip_torch else torch_models)
 def any_torch_model(request):
     return pytest.model_packages[request.param]
 
 
-@pytest.fixture(params=torchscript_models)
+@pytest.fixture(params=[] if skip_torch else torchscript_models)
 def any_torchscript_model(request):
     return pytest.model_packages[request.param]
 
 
-@pytest.fixture(params=onnx_models)
+@pytest.fixture(params=[] if skip_onnx else onnx_models)
 def any_onnx_model(request):
     return pytest.model_packages[request.param]
 
 
-@pytest.fixture(params=set(tensorflow1_models) | set(tensorflow2_models))
+@pytest.fixture(params=[] if skip_tensorflow else (set(tensorflow1_models) | set(tensorflow2_models)))
 def any_tensorflow_model(request):
     name = request.param
-    if (pytest.tf_major_version == 1 and name in tensorflow1_models) or (
-        pytest.tf_major_version == 2 and name in tensorflow2_models
-    ):
+    if (tf_major_version == 1 and name in tensorflow1_models) or (tf_major_version == 2 and name in tensorflow2_models):
         return pytest.model_packages[name]
 
 
-@pytest.fixture(params=keras_models)
+@pytest.fixture(params=[] if skip_keras else keras_models)
 def any_keras_model(request):
     return pytest.model_packages[request.param]
 
 
-@pytest.fixture(params=tensorflow_js_models)
+@pytest.fixture(params=[] if skip_tensorflow_js else tensorflow_js_models)
 def any_tensorflow_js_model(request):
     return pytest.model_packages[request.param]
 
 
-@pytest.fixture(params=model_sources.keys())
+# fixture to test with all models that should run in the current environment
+@pytest.fixture(params=load_model_packages)
 def any_model(request):
     return pytest.model_packages[request.param]
+
+
+#
+# temporary fixtures to test not with all, but only a manual selection of models
+# (models/functionality should be improved to get rid of this specific model group)
+#
+@pytest.fixture(params=[] if skip_torch else ["unet2d_nuclei_broad_model", "unet2d_fixed_shape"])
+def unet2d_fixed_shape_or_not(request):
+    return pytest.model_packages[request.param]
+
+
+@pytest.fixture(params=[] if skip_torch else ["unet2d_nuclei_broad_model", "unet2d_multi_tensor"])
+def unet2d_multi_tensor_or_not(request):
+    return pytest.model_packages[request.param]

tests/prediction_pipeline/test_prediction_pipeline.py

@@ -1,5 +1,4 @@
 import numpy as np
-import pytest
 import xarray as xr
 from numpy.testing import assert_array_almost_equal
 
@@ -31,31 +30,21 @@ def _test_prediction_pipeline(model_package, weight_format):
         assert_array_almost_equal(out, exp, decimal=4)
 
 
-@pytest.mark.skipif(pytest.skip_torch, reason="requires torch")
 def test_prediction_pipeline_torch(any_torch_model):
     _test_prediction_pipeline(any_torch_model, "pytorch_state_dict")
 
 
-@pytest.mark.skipif(pytest.skip_torch, reason="requires torch")
 def test_prediction_pipeline_torchscript(any_torchscript_model):
     _test_prediction_pipeline(any_torchscript_model, "pytorch_script")
 
 
-@pytest.mark.skipif(pytest.skip_onnx, reason="requires onnx")
 def test_prediction_pipeline_onnx(any_onnx_model):
     _test_prediction_pipeline(any_onnx_model, "onnx")
 
 
-@pytest.mark.skipif(pytest.skip_tensorflow or pytest.tf_major_version != 1, reason="requires tensorflow 1")
-def test_prediction_pipeline_tensorflow(any_tensorflow1_model):
-    _test_prediction_pipeline(any_tensorflow1_model, "tensorflow_saved_model_bundle")
+def test_prediction_pipeline_tensorflow(any_tensorflow_model):
+    _test_prediction_pipeline(any_tensorflow_model, "tensorflow_saved_model_bundle")
 
 
-@pytest.mark.skipif(pytest.skip_tensorflow or pytest.tf_major_version != 2, reason="requires tensorflow 2")
-def test_prediction_pipeline_tensorflow(any_tensorflow2_model):
-    _test_prediction_pipeline(any_tensorflow2_model, "tensorflow_saved_model_bundle")
-
-
-@pytest.mark.skipif(pytest.skip_keras, reason="requires keras")
 def test_prediction_pipeline_keras(any_keras_model):
     _test_prediction_pipeline(any_keras_model, "keras_hdf5")

tests/resource_io/test_load_rdf.py

@@ -38,23 +38,20 @@ def test_load_non_valid_rdf_name_invalid_suffix():
             load_resource_description(spec_path)
 
 
-@pytest.mark.skipif(pytest.skip_torch, reason="requires pytorch")
-def test_load_raw_model(unet2d_nuclei_broad_model):
+def test_load_raw_model(any_model):
     from bioimageio.core import load_raw_resource_description
 
-    raw_model = load_raw_resource_description(unet2d_nuclei_broad_model)
+    raw_model = load_raw_resource_description(any_model)
     assert raw_model
 
 
-@pytest.mark.skipif(pytest.skip_torch, reason="requires pytorch")
-def test_load_model(unet2d_nuclei_broad_model):
+def test_load_model(any_model):
     from bioimageio.core import load_resource_description
 
-    model = load_resource_description(unet2d_nuclei_broad_model)
+    model = load_resource_description(any_model)
     assert model
 
 
-@pytest.mark.skipif(pytest.skip_torch, reason="requires pytorch")
 def test_load_model_with_abs_path_source(unet2d_nuclei_broad_model):
     from bioimageio.core.resource_io import load_raw_resource_description, load_resource_description
 
@@ -65,7 +62,6 @@ def test_load_model_with_abs_path_source(unet2d_nuclei_broad_model):
     assert model
 
 
-@pytest.mark.skipif(pytest.skip_torch, reason="requires pytorch")
 def test_load_model_with_rel_path_source(unet2d_nuclei_broad_model):
     from bioimageio.core.resource_io import load_raw_resource_description, load_resource_description
 
@@ -76,7 +72,6 @@ def test_load_model_with_rel_path_source(unet2d_nuclei_broad_model):
     assert model
 
 
-@pytest.mark.skipif(pytest.skip_torch, reason="requires pytorch")
 def test_load_model_with_abs_str_source(unet2d_nuclei_broad_model):
     from bioimageio.core.resource_io import load_raw_resource_description, load_resource_description
 
@@ -87,7 +82,6 @@ def test_load_model_with_abs_str_source(unet2d_nuclei_broad_model):
     assert model
 
 
-@pytest.mark.skipif(pytest.skip_torch, reason="requires pytorch")
 def test_load_model_with_rel_str_source(unet2d_nuclei_broad_model):
     from bioimageio.core.resource_io import load_raw_resource_description, load_resource_description