bioimage.io model specification

Specification of the fields used in a bioimage.io-compliant RDF that describes AI models with pretrained weights.

These fields are typically stored in a YAML file which we call a model resource description file (model RDF).

General notes on this documentation:

symbol	explanation
`field`_{type hint}	A fields's _{expected type} may be shortened. If so, the abbreviated or full type is displayed below the field's description and can expanded to view further (nested) details if available.
Union[A, B, ...]	indicates that a field value may be of type A or B, etc.
Literal[a, b, ...]	indicates that a field value must be the specific value a or b, etc.
Type* := Type (restrictions)	A field Type* followed by an asterisk indicates that annotations, e.g. value restriction apply. These are listed in parentheses in the expanded type description. They are not always intuitively understandable and merely a hint at more complex validation.
<type>.v<major>_<minor>.<sub spec>	Subparts of a spec might be taken from another spec type or format version.
`field` ≝ `default`	Default field values are indicated after '≝' and make a field optional. However, `type` and `format_version` alwyas need to be set for resource descriptions written as YAML files and determine which bioimage.io specification applies. They are optional only when creating a resource description in Python code using the appropriate, `type` and `format_version` specific class.
`field` ≝ 🡇	Default field value is not displayed in-line, but in the code block below.
∈📦	Files referenced in fields which are marked with '∈📦 ' are included when packaging the resource to a .zip archive. The resource description YAML file (RDF) is always included well as 'rdf.yaml'.

`type`_{Literal[model]} ≝ `model`

Specialized resource type 'model'

`format_version`_{Literal[0.4.10]} ≝ `0.4.10`

Version of the bioimage.io model description specification used. When creating a new model always use the latest micro/patch version described here. The format_version is important for any consumer software to understand how to parse the fields.

`authors`_{Sequence[generic.v0_2.Author]}

The authors are the creators of the model RDF and the primary points of contact.

Sequence[generic.v0_2.Author]

generic.v0_2.Author:

`authors.i.affiliation`_{Optional[str]} ≝ `None`

Affiliation

`authors.i.email`_{Optional[Email]} ≝ `None`

Email

`authors.i.orcid`_Optional ≝ `None`

An ORCID iD in hyphenated groups of 4 digits, (and valid as per ISO 7064 11,2.) Example: '0000-0001-2345-6789'

Optional[_internal.types.OrcidId]

`authors.i.name`_str

`authors.i.github_user`_{Optional[str]} ≝ `None`

`description`_str

`documentation`_Union

∈📦 URL or relative path to a markdown file with additional documentation. The recommended documentation file name is README.md. An .md suffix is mandatory. The documentation should include a '[#[#]]# Validation' (sub)section with details on how to quantitatively validate the model on unseen data. Examples: ['https://github.com/raw/bioimage-io/spec-bioimage-io/main/example_descriptions/models/unet2d_nuclei_broad/README.md', '…']

Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))]

`inputs`_{Sequence[InputTensorDescr]}

Describes the input tensors expected by this model.

Sequence[InputTensorDescr]

InputTensorDescr:

`inputs.i.name`_TensorName

Tensor name. No duplicates are allowed.

`inputs.i.description`_str ≝ ``

`inputs.i.axes`_str

Axes identifying characters. Same length and order as the axes in shape.

axis	description
b	batch (groups multiple samples)
i	instance/index/element
t	time
c	channel
z	spatial dimension z
y	spatial dimension y
x	spatial dimension x

`inputs.i.data_range`_Optional ≝ `None`

Tuple (minimum, maximum) specifying the allowed range of the data in this tensor. If not specified, the full data range that can be expressed in data_type is allowed.

Optional[Sequence[float (allow_inf_nan=True), float (allow_inf_nan=True)]]

`inputs.i.data_type`_{Literal[float32, uint8, uint16]}

For now an input tensor is expected to be given as float32. The data flow in bioimage.io models is explained in this diagram..

`inputs.i.shape`_Union

Specification of input tensor shape. Examples: [(1, 512, 512, 1), {'min': (1, 64, 64, 1), 'step': (0, 32, 32, 0)}]

Union[Sequence[int], ParameterizedInputShape]

ParameterizedInputShape:

`inputs.i.shape.min`_{Sequence[int]}

The minimum input shape

`inputs.i.shape.step`_{Sequence[int]}

The minimum shape change

`inputs.i.preprocessing`_Sequence ≝ `[]`

Description of how this input should be preprocessed.

Sequence[Union[BinarizeDescr, ..., ScaleRangeDescr]*]

Sequence of Union[BinarizeDescr, ClipDescr, ScaleLinearDescr, SigmoidDescr, ZeroMeanUnitVarianceDescr, ScaleRangeDescr] (Discriminator(discriminator='name', custom_error_type=None, custom_error_message=None, custom_error_context=None))

BinarizeDescr:

`inputs.i.preprocessing.i.name`_{Literal[binarize]} ≝ `binarize`

`inputs.i.preprocessing.i.kwargs`_{BinarizeKwargs}

BinarizeKwargs

BinarizeKwargs:

`inputs.i.preprocessing.i.kwargs.threshold`_float

The fixed threshold

ClipDescr:

`inputs.i.preprocessing.i.name`_{Literal[clip]} ≝ `clip`

`inputs.i.preprocessing.i.kwargs`_ClipKwargs

ClipKwargs

ClipKwargs:

`inputs.i.preprocessing.i.kwargs.min`_float

minimum value for clipping

`inputs.i.preprocessing.i.kwargs.max`_float

maximum value for clipping

ScaleLinearDescr:

`inputs.i.preprocessing.i.name`_{Literal[scale_linear]} ≝ `scale_linear`

`inputs.i.preprocessing.i.kwargs`_{ScaleLinearKwargs}

ScaleLinearKwargs

ScaleLinearKwargs:

`inputs.i.preprocessing.i.kwargs.axes`_Optional ≝ `None`

The subset of axes to scale jointly. For example xy to scale the two image axes for 2d data jointly. Example: 'xy'

Optional[str (RestrictCharacters(alphabet='czyx'); AfterValidator(validate_unique_entries))]

`inputs.i.preprocessing.i.kwargs.gain`_{Union[float, Sequence[float]]} ≝ `1.0`

multiplicative factor

`inputs.i.preprocessing.i.kwargs.offset`_{Union[float, Sequence[float]]} ≝ `0.0`

additive term

SigmoidDescr:

`inputs.i.preprocessing.i.name`_{Literal[sigmoid]} ≝ `sigmoid`

ZeroMeanUnitVarianceDescr:

`inputs.i.preprocessing.i.name`_{Literal[zero_mean_unit_variance]} ≝ `zero_mean_unit_variance`

`inputs.i.preprocessing.i.kwargs`_{ZeroMeanUnitVarianceKwargs}

ZeroMeanUnitVarianceKwargs

ZeroMeanUnitVarianceKwargs:

`inputs.i.preprocessing.i.kwargs.mode`_Literal ≝ `fixed`

Mode for computing mean and variance.

mode	description
fixed	Fixed values for mean and variance
per_dataset	Compute for the entire dataset
per_sample	Compute for each sample individually

Literal[fixed, per_dataset, per_sample]

`inputs.i.preprocessing.i.kwargs.axes`_str

The subset of axes to normalize jointly. For example xy to normalize the two image axes for 2d data jointly. Example: 'xy'

`inputs.i.preprocessing.i.kwargs.mean`_Union ≝ `None`

The mean value(s) to use for mode: fixed. For example [1.1, 2.2, 3.3] in the case of a 3 channel image with axes: xy. Example: (1.1, 2.2, 3.3)

Union[float, Sequence[float] (MinLen(min_length=1)), None]

`inputs.i.preprocessing.i.kwargs.std`_Union ≝ `None`

The standard deviation values to use for mode: fixed. Analogous to mean. Example: (0.1, 0.2, 0.3)

Union[float, Sequence[float] (MinLen(min_length=1)), None]

`inputs.i.preprocessing.i.kwargs.eps`_float ≝ `1e-06`

epsilon for numeric stability: out = (tensor - mean) / (std + eps).

ScaleRangeDescr:

`inputs.i.preprocessing.i.name`_{Literal[scale_range]} ≝ `scale_range`

`inputs.i.preprocessing.i.kwargs`_{ScaleRangeKwargs}

ScaleRangeKwargs

ScaleRangeKwargs:

`inputs.i.preprocessing.i.kwargs.mode`_{Literal[per_dataset, per_sample]}

Mode for computing percentiles.

mode	description
per_dataset	compute for the entire dataset
per_sample	compute for each sample individually

`inputs.i.preprocessing.i.kwargs.axes`_str

The subset of axes to normalize jointly. For example xy to normalize the two image axes for 2d data jointly. Example: 'xy'

`inputs.i.preprocessing.i.kwargs.min_percentile`_{Union[int, float]} ≝ `0.0`

The lower percentile used for normalization.

`inputs.i.preprocessing.i.kwargs.max_percentile`_{Union[int, float]} ≝ `100.0`

The upper percentile used for normalization Has to be bigger than min_percentile. The range is 1 to 100 instead of 0 to 100 to avoid mistakenly accepting percentiles specified in the range 0.0 to 1.0.

`inputs.i.preprocessing.i.kwargs.eps`_float ≝ `1e-06`

Epsilon for numeric stability. out = (tensor - v_lower) / (v_upper - v_lower + eps); with v_lower,v_upper values at the respective percentiles.

`inputs.i.preprocessing.i.kwargs.reference_tensor`_{Optional[TensorName]} ≝ `None`

Tensor name to compute the percentiles from. Default: The tensor itself. For any tensor in inputs only input tensor references are allowed. For a tensor in outputs only input tensor refereences are allowed if mode: per_dataset

`license`_Union

A SPDX license identifier. We do notsupport custom license beyond the SPDX license list, if you need that please open a GitHub issue to discuss your intentions with the community. Examples: ['CC0-1.0', 'MIT', 'BSD-2-Clause']

Union[_internal.license_id.LicenseId, str]

`name`_str

A human-readable name of this model. It should be no longer than 64 characters and only contain letter, number, underscore, minus or space characters.

`outputs`_{Sequence[OutputTensorDescr]}

Describes the output tensors.

Sequence[OutputTensorDescr]

OutputTensorDescr:

`outputs.i.name`_TensorName

Tensor name. No duplicates are allowed.

`outputs.i.description`_str ≝ ``

`outputs.i.axes`_str

Axes identifying characters. Same length and order as the axes in shape.

axis	description
b	batch (groups multiple samples)
i	instance/index/element
t	time
c	channel
z	spatial dimension z
y	spatial dimension y
x	spatial dimension x

`outputs.i.data_range`_Optional ≝ `None`

Tuple (minimum, maximum) specifying the allowed range of the data in this tensor. If not specified, the full data range that can be expressed in data_type is allowed.

Optional[Sequence[float (allow_inf_nan=True), float (allow_inf_nan=True)]]

`outputs.i.data_type`_Literal

Data type. The data flow in bioimage.io models is explained in this diagram..

Literal[float32, float64, uint8, int8, uint16, int16, uint32, int32, uint64, int64, bool]

`outputs.i.shape`_Union

Output tensor shape.

Union[Sequence[int], ImplicitOutputShape]

ImplicitOutputShape:

`outputs.i.shape.reference_tensor`_TensorName

Name of the reference tensor.

`outputs.i.shape.scale`_{Sequence[Optional[float]]}

output_pix/input_pix for each dimension. 'null' values indicate new dimensions, whose length is defined by 2*offset

`outputs.i.shape.offset`_Sequence

Position of origin wrt to input.

Sequence[Union[int, float (MultipleOf(multiple_of=0.5))]]

`outputs.i.halo`_{Optional[Sequence[int]]} ≝ `None`

The halo that should be cropped from the output tensor to avoid boundary effects. The halo is to be cropped from both sides, i.e. shape_after_crop = shape - 2 * halo. To document a halo that is already cropped by the model shape.offset has to be used instead.

`outputs.i.postprocessing`_Sequence ≝ `[]`

Description of how this output should be postprocessed.

Sequence[Union[BinarizeDescr, ..., ScaleMeanVarianceDescr]*]

Sequence of Union of

BinarizeDescr
ClipDescr
ScaleLinearDescr
SigmoidDescr
ZeroMeanUnitVarianceDescr
ScaleRangeDescr
ScaleMeanVarianceDescr

(Discriminator(discriminator='name', custom_error_type=None, custom_error_message=None, custom_error_context=None))

BinarizeDescr:

`outputs.i.postprocessing.i.name`_{Literal[binarize]} ≝ `binarize`

`outputs.i.postprocessing.i.kwargs`_{BinarizeKwargs}

BinarizeKwargs

BinarizeKwargs:

`outputs.i.postprocessing.i.kwargs.threshold`_float

The fixed threshold

ClipDescr:

`outputs.i.postprocessing.i.name`_{Literal[clip]} ≝ `clip`

`outputs.i.postprocessing.i.kwargs`_ClipKwargs

ClipKwargs

ClipKwargs:

`outputs.i.postprocessing.i.kwargs.min`_float

minimum value for clipping

`outputs.i.postprocessing.i.kwargs.max`_float

maximum value for clipping

ScaleLinearDescr:

`outputs.i.postprocessing.i.name`_{Literal[scale_linear]} ≝ `scale_linear`

`outputs.i.postprocessing.i.kwargs`_{ScaleLinearKwargs}

ScaleLinearKwargs

ScaleLinearKwargs:

`outputs.i.postprocessing.i.kwargs.axes`_Optional ≝ `None`

The subset of axes to scale jointly. For example xy to scale the two image axes for 2d data jointly. Example: 'xy'

Optional[str (RestrictCharacters(alphabet='czyx'); AfterValidator(validate_unique_entries))]

`outputs.i.postprocessing.i.kwargs.gain`_{Union[float, Sequence[float]]} ≝ `1.0`

multiplicative factor

`outputs.i.postprocessing.i.kwargs.offset`_{Union[float, Sequence[float]]} ≝ `0.0`

additive term

SigmoidDescr:

`outputs.i.postprocessing.i.name`_{Literal[sigmoid]} ≝ `sigmoid`

ZeroMeanUnitVarianceDescr:

`outputs.i.postprocessing.i.name`_{Literal[zero_mean_unit_variance]} ≝ `zero_mean_unit_variance`

`outputs.i.postprocessing.i.kwargs`_{ZeroMeanUnitVarianceKwargs}

ZeroMeanUnitVarianceKwargs

ZeroMeanUnitVarianceKwargs:

`outputs.i.postprocessing.i.kwargs.mode`_Literal ≝ `fixed`

Mode for computing mean and variance.

mode	description
fixed	Fixed values for mean and variance
per_dataset	Compute for the entire dataset
per_sample	Compute for each sample individually

Literal[fixed, per_dataset, per_sample]

`outputs.i.postprocessing.i.kwargs.axes`_str

The subset of axes to normalize jointly. For example xy to normalize the two image axes for 2d data jointly. Example: 'xy'

`outputs.i.postprocessing.i.kwargs.mean`_Union ≝ `None`

The mean value(s) to use for mode: fixed. For example [1.1, 2.2, 3.3] in the case of a 3 channel image with axes: xy. Example: (1.1, 2.2, 3.3)

Union[float, Sequence[float] (MinLen(min_length=1)), None]

`outputs.i.postprocessing.i.kwargs.std`_Union ≝ `None`

The standard deviation values to use for mode: fixed. Analogous to mean. Example: (0.1, 0.2, 0.3)

Union[float, Sequence[float] (MinLen(min_length=1)), None]

`outputs.i.postprocessing.i.kwargs.eps`_float ≝ `1e-06`

epsilon for numeric stability: out = (tensor - mean) / (std + eps).

ScaleRangeDescr:

`outputs.i.postprocessing.i.name`_{Literal[scale_range]} ≝ `scale_range`

`outputs.i.postprocessing.i.kwargs`_{ScaleRangeKwargs}

ScaleRangeKwargs

ScaleRangeKwargs:

`outputs.i.postprocessing.i.kwargs.mode`_{Literal[per_dataset, per_sample]}

Mode for computing percentiles.

mode	description
per_dataset	compute for the entire dataset
per_sample	compute for each sample individually

`outputs.i.postprocessing.i.kwargs.axes`_str

The subset of axes to normalize jointly. For example xy to normalize the two image axes for 2d data jointly. Example: 'xy'

`outputs.i.postprocessing.i.kwargs.min_percentile`_{Union[int, float]} ≝ `0.0`

The lower percentile used for normalization.

`outputs.i.postprocessing.i.kwargs.max_percentile`_{Union[int, float]} ≝ `100.0`

The upper percentile used for normalization Has to be bigger than min_percentile. The range is 1 to 100 instead of 0 to 100 to avoid mistakenly accepting percentiles specified in the range 0.0 to 1.0.

`outputs.i.postprocessing.i.kwargs.eps`_float ≝ `1e-06`

Epsilon for numeric stability. out = (tensor - v_lower) / (v_upper - v_lower + eps); with v_lower,v_upper values at the respective percentiles.

`outputs.i.postprocessing.i.kwargs.reference_tensor`_{Optional[TensorName]} ≝ `None`

Tensor name to compute the percentiles from. Default: The tensor itself. For any tensor in inputs only input tensor references are allowed. For a tensor in outputs only input tensor refereences are allowed if mode: per_dataset

ScaleMeanVarianceDescr:

`outputs.i.postprocessing.i.name`_{Literal[scale_mean_variance]} ≝ `scale_mean_variance`

`outputs.i.postprocessing.i.kwargs`_{ScaleMeanVarianceKwargs}

ScaleMeanVarianceKwargs

ScaleMeanVarianceKwargs:

`outputs.i.postprocessing.i.kwargs.mode`_{Literal[per_dataset, per_sample]}

Mode for computing mean and variance.

mode	description
per_dataset	Compute for the entire dataset
per_sample	Compute for each sample individually

`outputs.i.postprocessing.i.kwargs.reference_tensor`_TensorName

Name of tensor to match.

`outputs.i.postprocessing.i.kwargs.axes`_Optional ≝ `None`

The subset of axes to scale jointly. For example xy to normalize the two image axes for 2d data jointly. Default: scale all non-batch axes jointly. Example: 'xy'

Optional[str (RestrictCharacters(alphabet='czyx'); AfterValidator(validate_unique_entries))]

`outputs.i.postprocessing.i.kwargs.eps`_float ≝ `1e-06`

Epsilon for numeric stability: "`out = (tensor - mean) / (std + eps) * (ref_std + eps) + ref_mean.

`test_inputs`_Sequence

∈📦 Test input tensors compatible with the inputs description for a single test case. This means if your model has more than one input, you should provide one URL/relative path for each input. Each test input should be a file with an ndarray in numpy.lib file format. The extension must be '.npy'.

Sequence[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*]

Sequence of Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right'; AfterValidator(wo_special_file_name); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'); WithSuffix(suffix='.npy', case_sensitive=True))

`test_outputs`_Sequence

∈📦 Analog to test_inputs.

Sequence[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*]

Sequence of Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right'; AfterValidator(wo_special_file_name); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'); WithSuffix(suffix='.npy', case_sensitive=True))

`timestamp`_{_internal.types.Datetime}

Timestamp in ISO 8601 format with a few restrictions listed here.

`weights`_WeightsDescr

The weights for this model. Weights can be given for different formats, but should otherwise be equivalent. The available weight formats determine which consumers can use this model.

WeightsDescr

WeightsDescr:

`weights.keras_hdf5`_{Optional[KerasHdf5WeightsDescr]} ≝ `None`

Optional[KerasHdf5WeightsDescr]

KerasHdf5WeightsDescr:

`weights.keras_hdf5.source`_Union

∈📦 The weights file.

Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))]

`weights.keras_hdf5.sha256`_Optional ≝ `None`

SHA256 checksum of the source file

Optional[_internal.io_basics.Sha256]

`weights.keras_hdf5.attachments`_Optional ≝ `None`

Attachments that are specific to this weights entry.

Optional[generic.v0_2.AttachmentsDescr]

generic.v0_2.AttachmentsDescr:

`weights.keras_hdf5.attachments.files`_Sequence ≝ `[]`

∈📦 File attachments

Sequence[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*]

Sequence of Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right'; AfterValidator(wo_special_file_name); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'))

`weights.keras_hdf5.authors`_Optional ≝ `None`

Authors Either the person(s) that have trained this model resulting in the original weights file. (If this is the initial weights entry, i.e. it does not have a parent) Or the person(s) who have converted the weights to this weights format. (If this is a child weight, i.e. it has a parent field)

Optional[Sequence[generic.v0_2.Author]]

generic.v0_2.Author:

`weights.keras_hdf5.authors.i.affiliation`_{Optional[str]} ≝ `None`

Affiliation

`weights.keras_hdf5.authors.i.email`_{Optional[Email]} ≝ `None`

Email

`weights.keras_hdf5.authors.i.orcid`_Optional ≝ `None`

An ORCID iD in hyphenated groups of 4 digits, (and valid as per ISO 7064 11,2.) Example: '0000-0001-2345-6789'

Optional[_internal.types.OrcidId]

`weights.keras_hdf5.authors.i.name`_str

`weights.keras_hdf5.authors.i.github_user`_{Optional[str]} ≝ `None`

`weights.keras_hdf5.dependencies`_{Optional[Dependencies]} ≝ `None`

Dependency manager and dependency file, specified as <dependency manager>:<relative file path>. Examples: ['conda:environment.yaml', 'maven:./pom.xml', 'pip:./requirements.txt']

`weights.keras_hdf5.parent`_Optional ≝ `None`

The source weights these weights were converted from. For example, if a model's weights were converted from the pytorch_state_dict format to torchscript, The pytorch_state_dict weights entry has no parent and is the parent of the torchscript weights. All weight entries except one (the initial set of weights resulting from training the model), need to have this field. Example: 'pytorch_state_dict'

Optional[Literal[keras_hdf5, onnx, pytorch_state_dict, tensorflow_js, tensorflow_saved_model_bundle, torchscript]]

`weights.keras_hdf5.tensorflow_version`_Optional ≝ `None`

TensorFlow version used to create these weights

Optional[_internal.version_type.Version]

`weights.onnx`_{Optional[OnnxWeightsDescr]} ≝ `None`

Optional[OnnxWeightsDescr]

OnnxWeightsDescr:

`weights.onnx.source`_Union

∈📦 The weights file.

Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))]

`weights.onnx.sha256`_Optional ≝ `None`

SHA256 checksum of the source file

Optional[_internal.io_basics.Sha256]

`weights.onnx.attachments`_Optional ≝ `None`

Attachments that are specific to this weights entry.

Optional[generic.v0_2.AttachmentsDescr]

generic.v0_2.AttachmentsDescr:

`weights.onnx.attachments.files`_Sequence ≝ `[]`

∈📦 File attachments

Sequence[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*]

Sequence of Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right'; AfterValidator(wo_special_file_name); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'))

`weights.onnx.authors`_Optional ≝ `None`

Authors Either the person(s) that have trained this model resulting in the original weights file. (If this is the initial weights entry, i.e. it does not have a parent) Or the person(s) who have converted the weights to this weights format. (If this is a child weight, i.e. it has a parent field)

Optional[Sequence[generic.v0_2.Author]]

generic.v0_2.Author:

`weights.onnx.authors.i.affiliation`_{Optional[str]} ≝ `None`

Affiliation

`weights.onnx.authors.i.email`_{Optional[Email]} ≝ `None`

Email

`weights.onnx.authors.i.orcid`_Optional ≝ `None`

An ORCID iD in hyphenated groups of 4 digits, (and valid as per ISO 7064 11,2.) Example: '0000-0001-2345-6789'

Optional[_internal.types.OrcidId]

`weights.onnx.authors.i.name`_str

`weights.onnx.authors.i.github_user`_{Optional[str]} ≝ `None`

`weights.onnx.dependencies`_{Optional[Dependencies]} ≝ `None`

Dependency manager and dependency file, specified as <dependency manager>:<relative file path>. Examples: ['conda:environment.yaml', 'maven:./pom.xml', 'pip:./requirements.txt']

`weights.onnx.parent`_Optional ≝ `None`

The source weights these weights were converted from. For example, if a model's weights were converted from the pytorch_state_dict format to torchscript, The pytorch_state_dict weights entry has no parent and is the parent of the torchscript weights. All weight entries except one (the initial set of weights resulting from training the model), need to have this field. Example: 'pytorch_state_dict'

Optional[Literal[keras_hdf5, onnx, pytorch_state_dict, tensorflow_js, tensorflow_saved_model_bundle, torchscript]]

`weights.onnx.opset_version`_{Optional[int (Ge(ge=7))]} ≝ `None`

ONNX opset version

`weights.pytorch_state_dict`_Optional ≝ `None`

Optional[PytorchStateDictWeightsDescr]

PytorchStateDictWeightsDescr:

`weights.pytorch_state_dict.source`_Union

∈📦 The weights file.

Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))]

`weights.pytorch_state_dict.sha256`_Optional ≝ `None`

SHA256 checksum of the source file

Optional[_internal.io_basics.Sha256]

`weights.pytorch_state_dict.attachments`_Optional ≝ `None`

Attachments that are specific to this weights entry.

Optional[generic.v0_2.AttachmentsDescr]

generic.v0_2.AttachmentsDescr:

`weights.pytorch_state_dict.attachments.files`_Sequence ≝ `[]`

∈📦 File attachments

Sequence[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*]

Sequence of Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right'; AfterValidator(wo_special_file_name); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'))

`weights.pytorch_state_dict.authors`_Optional ≝ `None`

Authors Either the person(s) that have trained this model resulting in the original weights file. (If this is the initial weights entry, i.e. it does not have a parent) Or the person(s) who have converted the weights to this weights format. (If this is a child weight, i.e. it has a parent field)

Optional[Sequence[generic.v0_2.Author]]

generic.v0_2.Author:

`weights.pytorch_state_dict.authors.i.affiliation`_{Optional[str]} ≝ `None`

Affiliation

`weights.pytorch_state_dict.authors.i.email`_{Optional[Email]} ≝ `None`

Email

`weights.pytorch_state_dict.authors.i.orcid`_Optional ≝ `None`

An ORCID iD in hyphenated groups of 4 digits, (and valid as per ISO 7064 11,2.) Example: '0000-0001-2345-6789'

Optional[_internal.types.OrcidId]

`weights.pytorch_state_dict.authors.i.name`_str

`weights.pytorch_state_dict.authors.i.github_user`_{Optional[str]} ≝ `None`

`weights.pytorch_state_dict.dependencies`_{Optional[Dependencies]} ≝ `None`

Dependency manager and dependency file, specified as <dependency manager>:<relative file path>. Examples: ['conda:environment.yaml', 'maven:./pom.xml', 'pip:./requirements.txt']

`weights.pytorch_state_dict.parent`_Optional ≝ `None`

The source weights these weights were converted from. For example, if a model's weights were converted from the pytorch_state_dict format to torchscript, The pytorch_state_dict weights entry has no parent and is the parent of the torchscript weights. All weight entries except one (the initial set of weights resulting from training the model), need to have this field. Example: 'pytorch_state_dict'

Optional[Literal[keras_hdf5, onnx, pytorch_state_dict, tensorflow_js, tensorflow_saved_model_bundle, torchscript]]

`weights.pytorch_state_dict.architecture`_Union

callable returning a torch.nn.Module instance. Local implementation: <relative path to file>:<identifier of implementation within the file>. Implementation in a dependency: <dependency-package>.<[dependency-module]>.<identifier>. Examples: ['my_function.py:MyNetworkClass', 'my_module.submodule.get_my_model']

Union[CallableFromFile, CallableFromDepencency]

`weights.pytorch_state_dict.architecture_sha256`_Optional ≝ `None`

The SHA256 of the architecture source file, if the architecture is not defined in a module listed in dependencies You can drag and drop your file to this online tool to generate a SHA256 in your browser. Or you can generate a SHA256 checksum with Python's hashlib, here is a codesnippet.

Optional[_internal.io_basics.Sha256]

`weights.pytorch_state_dict.kwargs`_{Dict[str, Any]} ≝ `{}`

key word arguments for the architecture callable

`weights.pytorch_state_dict.pytorch_version`_Optional ≝ `None`

Version of the PyTorch library used. If depencencies is specified it should include pytorch and the verison has to match. (dependencies overrules pytorch_version)

Optional[_internal.version_type.Version]

`weights.tensorflow_js`_Optional ≝ `None`

Optional[TensorflowJsWeightsDescr]

TensorflowJsWeightsDescr:

`weights.tensorflow_js.source`_Union

∈📦 The multi-file weights. All required files/folders should be a zip archive.

Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))]

`weights.tensorflow_js.sha256`_Optional ≝ `None`

SHA256 checksum of the source file

Optional[_internal.io_basics.Sha256]

`weights.tensorflow_js.attachments`_Optional ≝ `None`

Attachments that are specific to this weights entry.

Optional[generic.v0_2.AttachmentsDescr]

generic.v0_2.AttachmentsDescr:

`weights.tensorflow_js.attachments.files`_Sequence ≝ `[]`

∈📦 File attachments

Sequence[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*]

Sequence of Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right'; AfterValidator(wo_special_file_name); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'))

`weights.tensorflow_js.authors`_Optional ≝ `None`

Authors Either the person(s) that have trained this model resulting in the original weights file. (If this is the initial weights entry, i.e. it does not have a parent) Or the person(s) who have converted the weights to this weights format. (If this is a child weight, i.e. it has a parent field)

Optional[Sequence[generic.v0_2.Author]]

generic.v0_2.Author:

`weights.tensorflow_js.authors.i.affiliation`_{Optional[str]} ≝ `None`

Affiliation

`weights.tensorflow_js.authors.i.email`_{Optional[Email]} ≝ `None`

Email

`weights.tensorflow_js.authors.i.orcid`_Optional ≝ `None`

An ORCID iD in hyphenated groups of 4 digits, (and valid as per ISO 7064 11,2.) Example: '0000-0001-2345-6789'

Optional[_internal.types.OrcidId]

`weights.tensorflow_js.authors.i.name`_str

`weights.tensorflow_js.authors.i.github_user`_{Optional[str]} ≝ `None`

`weights.tensorflow_js.dependencies`_{Optional[Dependencies]} ≝ `None`

Dependency manager and dependency file, specified as <dependency manager>:<relative file path>. Examples: ['conda:environment.yaml', 'maven:./pom.xml', 'pip:./requirements.txt']

`weights.tensorflow_js.parent`_Optional ≝ `None`

The source weights these weights were converted from. For example, if a model's weights were converted from the pytorch_state_dict format to torchscript, The pytorch_state_dict weights entry has no parent and is the parent of the torchscript weights. All weight entries except one (the initial set of weights resulting from training the model), need to have this field. Example: 'pytorch_state_dict'

Optional[Literal[keras_hdf5, onnx, pytorch_state_dict, tensorflow_js, tensorflow_saved_model_bundle, torchscript]]

`weights.tensorflow_js.tensorflow_version`_Optional ≝ `None`

Version of the TensorFlow library used.

Optional[_internal.version_type.Version]

`weights.tensorflow_saved_model_bundle`_Optional ≝ `None`

Optional[TensorflowSavedModelBundleWeightsDescr]

TensorflowSavedModelBundleWeightsDescr:

`weights.tensorflow_saved_model_bundle.source`_Union

∈📦 The weights file.

Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))]

`weights.tensorflow_saved_model_bundle.sha256`_Optional ≝ `None`

SHA256 checksum of the source file

Optional[_internal.io_basics.Sha256]

`weights.tensorflow_saved_model_bundle.attachments`_Optional ≝ `None`

Attachments that are specific to this weights entry.

Optional[generic.v0_2.AttachmentsDescr]

generic.v0_2.AttachmentsDescr:

`weights.tensorflow_saved_model_bundle.attachments.files`_Sequence ≝ `[]`

∈📦 File attachments

Sequence[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*]

Sequence of Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right'; AfterValidator(wo_special_file_name); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'))

`weights.tensorflow_saved_model_bundle.authors`_Optional ≝ `None`

Authors Either the person(s) that have trained this model resulting in the original weights file. (If this is the initial weights entry, i.e. it does not have a parent) Or the person(s) who have converted the weights to this weights format. (If this is a child weight, i.e. it has a parent field)

Optional[Sequence[generic.v0_2.Author]]

generic.v0_2.Author:

`weights.tensorflow_saved_model_bundle.authors.i.affiliation`_{Optional[str]} ≝ `None`

Affiliation

`weights.tensorflow_saved_model_bundle.authors.i.email`_{Optional[Email]} ≝ `None`

Email

`weights.tensorflow_saved_model_bundle.authors.i.orcid`_Optional ≝ `None`

An ORCID iD in hyphenated groups of 4 digits, (and valid as per ISO 7064 11,2.) Example: '0000-0001-2345-6789'

Optional[_internal.types.OrcidId]

`weights.tensorflow_saved_model_bundle.authors.i.name`_str

`weights.tensorflow_saved_model_bundle.authors.i.github_user`_{Optional[str]} ≝ `None`

`weights.tensorflow_saved_model_bundle.dependencies`_{Optional[Dependencies]} ≝ `None`

Dependency manager and dependency file, specified as <dependency manager>:<relative file path>. Examples: ['conda:environment.yaml', 'maven:./pom.xml', 'pip:./requirements.txt']

`weights.tensorflow_saved_model_bundle.parent`_Optional ≝ `None`

The source weights these weights were converted from. For example, if a model's weights were converted from the pytorch_state_dict format to torchscript, The pytorch_state_dict weights entry has no parent and is the parent of the torchscript weights. All weight entries except one (the initial set of weights resulting from training the model), need to have this field. Example: 'pytorch_state_dict'

Optional[Literal[keras_hdf5, onnx, pytorch_state_dict, tensorflow_js, tensorflow_saved_model_bundle, torchscript]]

`weights.tensorflow_saved_model_bundle.tensorflow_version`_Optional ≝ `None`

Version of the TensorFlow library used.

Optional[_internal.version_type.Version]

`weights.torchscript`_Optional ≝ `None`

Optional[TorchscriptWeightsDescr]

TorchscriptWeightsDescr:

`weights.torchscript.source`_Union

∈📦 The weights file.

Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))]

`weights.torchscript.sha256`_Optional ≝ `None`

SHA256 checksum of the source file

Optional[_internal.io_basics.Sha256]

`weights.torchscript.attachments`_Optional ≝ `None`

Attachments that are specific to this weights entry.

Optional[generic.v0_2.AttachmentsDescr]

generic.v0_2.AttachmentsDescr:

`weights.torchscript.attachments.files`_Sequence ≝ `[]`

∈📦 File attachments

Sequence[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*]

Sequence of Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right'; AfterValidator(wo_special_file_name); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'))

`weights.torchscript.authors`_Optional ≝ `None`

Authors Either the person(s) that have trained this model resulting in the original weights file. (If this is the initial weights entry, i.e. it does not have a parent) Or the person(s) who have converted the weights to this weights format. (If this is a child weight, i.e. it has a parent field)

Optional[Sequence[generic.v0_2.Author]]

generic.v0_2.Author:

`weights.torchscript.authors.i.affiliation`_{Optional[str]} ≝ `None`

Affiliation

`weights.torchscript.authors.i.email`_{Optional[Email]} ≝ `None`

Email

`weights.torchscript.authors.i.orcid`_Optional ≝ `None`

An ORCID iD in hyphenated groups of 4 digits, (and valid as per ISO 7064 11,2.) Example: '0000-0001-2345-6789'

Optional[_internal.types.OrcidId]

`weights.torchscript.authors.i.name`_str

`weights.torchscript.authors.i.github_user`_{Optional[str]} ≝ `None`

`weights.torchscript.dependencies`_{Optional[Dependencies]} ≝ `None`

Dependency manager and dependency file, specified as <dependency manager>:<relative file path>. Examples: ['conda:environment.yaml', 'maven:./pom.xml', 'pip:./requirements.txt']

`weights.torchscript.parent`_Optional ≝ `None`

The source weights these weights were converted from. For example, if a model's weights were converted from the pytorch_state_dict format to torchscript, The pytorch_state_dict weights entry has no parent and is the parent of the torchscript weights. All weight entries except one (the initial set of weights resulting from training the model), need to have this field. Example: 'pytorch_state_dict'

Optional[Literal[keras_hdf5, onnx, pytorch_state_dict, tensorflow_js, tensorflow_saved_model_bundle, torchscript]]

`weights.torchscript.pytorch_version`_Optional ≝ `None`

Version of the PyTorch library used.

Optional[_internal.version_type.Version]

`attachments`_Optional ≝ `None`

file and other attachments

Optional[generic.v0_2.AttachmentsDescr]

generic.v0_2.AttachmentsDescr:

`attachments.files`_Sequence ≝ `[]`

∈📦 File attachments

Sequence[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*]

Sequence of Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right'; AfterValidator(wo_special_file_name); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'))

`cite`_{Sequence[generic.v0_2.CiteEntry]} ≝ `[]`

citations

Sequence[generic.v0_2.CiteEntry]

generic.v0_2.CiteEntry:

`cite.i.text`_str

free text description

`cite.i.doi`_{Optional[_internal.types.Doi]} ≝ `None`

A digital object identifier (DOI) is the prefered citation reference. See https://www.doi.org/ for details. (alternatively specify url)

`cite.i.url`_{Optional[str]} ≝ `None`

URL to cite (preferably specify a doi instead)

`config`_{Dict[str, YamlValue]} ≝ `{}`

A field for custom configuration that can contain any keys not present in the RDF spec. This means you should not store, for example, a github repo URL in config since we already have the git_repo field defined in the spec. Keys in config may be very specific to a tool or consumer software. To avoid conflicting definitions, it is recommended to wrap added configuration into a sub-field named with the specific domain or tool name, for example:

config:
    bioimageio:  # here is the domain name
        my_custom_key: 3837283
        another_key:
            nested: value
    imagej:       # config specific to ImageJ
        macro_dir: path/to/macro/file

If possible, please use snake_case for keys in config. You may want to list linked files additionally under attachments to include them when packaging a resource (packaging a resource means downloading/copying important linked files and creating a ZIP archive that contains an altered rdf.yaml file with local references to the downloaded files) Example: {'bioimageio': {'my_custom_key': 3837283, 'another_key': {'nested': 'value'}}, 'imagej': {'macro_dir': 'path/to/macro/file'}}

`covers`_Sequence ≝ `[]`

Cover images. Please use an image smaller than 500KB and an aspect ratio width to height of 2:1. The supported image formats are: ('.gif', '.jpeg', '.jpg', '.png', '.svg', '.tif', '.tiff') Example: 'cover.png'

Sequence[Union[Path*, _internal.io.RelativeFilePath, _internal.url.HttpUrl]*]

Sequence of Union[Path (PathType(path_type='file'); Predicate(is_absolute)), _internal.io.RelativeFilePath, _internal.url.HttpUrl] (union_mode='left_to_right'; WithSuffix(suffix=('.gif', '.jpeg', '.jpg', '.png', '.svg', '.tif', '.tiff'), case_sensitive=False); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'))

`download_url`_{Optional[_internal.url.HttpUrl]} ≝ `None`

URL to download the resource from (deprecated)

`git_repo`_{Optional[str]} ≝ `None`

A URL to the Git repository where the resource is being developed. Example: 'https://github.com/bioimage-io/spec-bioimage-io/tree/main/example_descriptions/models/unet2d_nuclei_broad'

`icon`_Union ≝ `None`

An icon for illustration

Union[str*, Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*, None]

Union of

str (Len(min_length=1, max_length=2))
Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right'; AfterValidator(wo_special_file_name); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'))
None

`id`_{Optional[ModelId]} ≝ `None`

Model zoo (bioimage.io) wide, unique identifier (assigned by bioimage.io)

`id_emoji`_Optional ≝ `None`

UTF-8 emoji for display alongside the id.

Optional[str (Len(min_length=1, max_length=1))]

`links`_{Sequence[str]} ≝ `[]`

IDs of other bioimage.io resources Example: ('ilastik/ilastik', 'deepimagej/deepimagej', 'zero/notebook_u-net_3d_zerocostdl4mic')

`maintainers`_Sequence ≝ `[]`

Maintainers of this resource. If not specified authors are maintainers and at least some of them should specify their github_user name

Sequence[generic.v0_2.Maintainer]

generic.v0_2.Maintainer:

`maintainers.i.affiliation`_{Optional[str]} ≝ `None`

Affiliation

`maintainers.i.email`_{Optional[Email]} ≝ `None`

Email

`maintainers.i.orcid`_Optional ≝ `None`

An ORCID iD in hyphenated groups of 4 digits, (and valid as per ISO 7064 11,2.) Example: '0000-0001-2345-6789'

Optional[_internal.types.OrcidId]

`maintainers.i.name`_Optional ≝ `None`

Optional[str (AfterValidator(_remove_slashes))]

`maintainers.i.github_user`_str

`packaged_by`_{Sequence[generic.v0_2.Author]} ≝ `[]`

The persons that have packaged and uploaded this model. Only required if those persons differ from the authors.

Sequence[generic.v0_2.Author]

generic.v0_2.Author:

`packaged_by.i.affiliation`_{Optional[str]} ≝ `None`

Affiliation

`packaged_by.i.email`_{Optional[Email]} ≝ `None`

Email

`packaged_by.i.orcid`_Optional ≝ `None`

An ORCID iD in hyphenated groups of 4 digits, (and valid as per ISO 7064 11,2.) Example: '0000-0001-2345-6789'

Optional[_internal.types.OrcidId]

`packaged_by.i.name`_str

`packaged_by.i.github_user`_{Optional[str]} ≝ `None`

`parent`_{Optional[LinkedModel]} ≝ `None`

The model from which this model is derived, e.g. by fine-tuning the weights.

Optional[LinkedModel]

LinkedModel:

`parent.id`_ModelId

A valid model id from the bioimage.io collection.

`parent.version_number`_{Optional[int]} ≝ `None`

version number (n-th published version, not the semantic version) of linked model

`rdf_source`_Optional ≝ `None`

Resource description file (RDF) source; used to keep track of where an rdf.yaml was loaded from. Do not set this field in a YAML file.

Optional[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*]

Optional[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right')]

`run_mode`_{Optional[RunMode]} ≝ `None`

Custom run mode for this model: for more complex prediction procedures like test time data augmentation that currently cannot be expressed in the specification. No standard run modes are defined yet.

Optional[RunMode]

RunMode:

`run_mode.name`_{Union[Literal[deepimagej], str]}

Run mode name

`run_mode.kwargs`_{Dict[str, Any]} ≝ `{}`

Run mode specific key word arguments

`sample_inputs`_Sequence ≝ `[]`

∈📦 URLs/relative paths to sample inputs to illustrate possible inputs for the model, for example stored as PNG or TIFF images. The sample files primarily serve to inform a human user about an example use case

Sequence[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*]

Sequence of Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right'; AfterValidator(wo_special_file_name); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'))

`sample_outputs`_Sequence ≝ `[]`

∈📦 URLs/relative paths to sample outputs corresponding to the sample_inputs.

Sequence[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*]

Sequence of Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right'; AfterValidator(wo_special_file_name); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'))

`tags`_{Sequence[str]} ≝ `[]`

Associated tags Example: ('unet2d', 'pytorch', 'nucleus', 'segmentation', 'dsb2018')

`training_data`_Union ≝ `None`

The dataset used to train this model

Union[dataset.v0_2.LinkedDataset, dataset.v0_2.DatasetDescr, None]

dataset.v0_2.LinkedDataset:

`training_data.id`_{dataset.v0_2.DatasetId}

A valid dataset id from the bioimage.io collection.

`training_data.version_number`_{Optional[int]} ≝ `None`

version number (n-th published version, not the semantic version) of linked dataset

dataset.v0_2.DatasetDescr:

`training_data.name`_str

A human-friendly name of the resource description

`training_data.description`_str

`training_data.covers`_Sequence ≝ `[]`

Cover images. Please use an image smaller than 500KB and an aspect ratio width to height of 2:1. The supported image formats are: ('.gif', '.jpeg', '.jpg', '.png', '.svg', '.tif', '.tiff') Example: 'cover.png'

Sequence[Union[Path*, _internal.io.RelativeFilePath, _internal.url.HttpUrl]*]

Sequence of Union[Path (PathType(path_type='file'); Predicate(is_absolute)), _internal.io.RelativeFilePath, _internal.url.HttpUrl] (union_mode='left_to_right'; WithSuffix(suffix=('.gif', '.jpeg', '.jpg', '.png', '.svg', '.tif', '.tiff'), case_sensitive=False); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'))

`training_data.id_emoji`_Optional ≝ `None`

UTF-8 emoji for display alongside the id.

Optional[str (Len(min_length=1, max_length=1))]

`training_data.authors`_{Sequence[generic.v0_2.Author]} ≝ `[]`

The authors are the creators of the RDF and the primary points of contact.

Sequence[generic.v0_2.Author]

generic.v0_2.Author:

`training_data.authors.i.affiliation`_{Optional[str]} ≝ `None`

Affiliation

`training_data.authors.i.email`_{Optional[Email]} ≝ `None`

Email

`training_data.authors.i.orcid`_Optional ≝ `None`

An ORCID iD in hyphenated groups of 4 digits, (and valid as per ISO 7064 11,2.) Example: '0000-0001-2345-6789'

Optional[_internal.types.OrcidId]

`training_data.authors.i.name`_str

`training_data.authors.i.github_user`_{Optional[str]} ≝ `None`

`training_data.attachments`_Optional ≝ `None`

file and other attachments

Optional[generic.v0_2.AttachmentsDescr]

generic.v0_2.AttachmentsDescr:

`training_data.attachments.files`_Sequence ≝ `[]`

∈📦 File attachments

Sequence[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*]

Sequence of Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right'; AfterValidator(wo_special_file_name); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'))

`training_data.cite`_{Sequence[generic.v0_2.CiteEntry]} ≝ `[]`

citations

Sequence[generic.v0_2.CiteEntry]

generic.v0_2.CiteEntry:

`training_data.cite.i.text`_str

free text description

`training_data.cite.i.doi`_{Optional[_internal.types.Doi]} ≝ `None`

A digital object identifier (DOI) is the prefered citation reference. See https://www.doi.org/ for details. (alternatively specify url)

`training_data.cite.i.url`_{Optional[str]} ≝ `None`

URL to cite (preferably specify a doi instead)

`training_data.config`_{Dict[str, YamlValue]} ≝ `{}`

A field for custom configuration that can contain any keys not present in the RDF spec. This means you should not store, for example, a github repo URL in config since we already have the git_repo field defined in the spec. Keys in config may be very specific to a tool or consumer software. To avoid conflicting definitions, it is recommended to wrap added configuration into a sub-field named with the specific domain or tool name, for example:

config:
    bioimageio:  # here is the domain name
        my_custom_key: 3837283
        another_key:
            nested: value
    imagej:       # config specific to ImageJ
        macro_dir: path/to/macro/file

If possible, please use snake_case for keys in config. You may want to list linked files additionally under attachments to include them when packaging a resource (packaging a resource means downloading/copying important linked files and creating a ZIP archive that contains an altered rdf.yaml file with local references to the downloaded files) Example: {'bioimageio': {'my_custom_key': 3837283, 'another_key': {'nested': 'value'}}, 'imagej': {'macro_dir': 'path/to/macro/file'}}

`training_data.download_url`_{Optional[_internal.url.HttpUrl]} ≝ `None`

URL to download the resource from (deprecated)

`training_data.git_repo`_{Optional[str]} ≝ `None`

A URL to the Git repository where the resource is being developed. Example: 'https://github.com/bioimage-io/spec-bioimage-io/tree/main/example_descriptions/models/unet2d_nuclei_broad'

`training_data.icon`_Union ≝ `None`

An icon for illustration

Union[str*, Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*, None]

Union of

str (Len(min_length=1, max_length=2))
Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right'; AfterValidator(wo_special_file_name); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'))
None

`training_data.links`_{Sequence[str]} ≝ `[]`

IDs of other bioimage.io resources Example: ('ilastik/ilastik', 'deepimagej/deepimagej', 'zero/notebook_u-net_3d_zerocostdl4mic')

`training_data.uploader`_{Optional[generic.v0_2.Uploader]} ≝ `None`

The person who uploaded the model (e.g. to bioimage.io)

Optional[generic.v0_2.Uploader]

generic.v0_2.Uploader:

`training_data.uploader.email`_Email

Email

`training_data.uploader.name`_Optional ≝ `None`

name

Optional[str (AfterValidator(_remove_slashes))]

`training_data.maintainers`_Sequence ≝ `[]`

Maintainers of this resource. If not specified authors are maintainers and at least some of them should specify their github_user name

Sequence[generic.v0_2.Maintainer]

generic.v0_2.Maintainer:

`training_data.maintainers.i.affiliation`_{Optional[str]} ≝ `None`

Affiliation

`training_data.maintainers.i.email`_{Optional[Email]} ≝ `None`

Email

`training_data.maintainers.i.orcid`_Optional ≝ `None`

An ORCID iD in hyphenated groups of 4 digits, (and valid as per ISO 7064 11,2.) Example: '0000-0001-2345-6789'

Optional[_internal.types.OrcidId]

`training_data.maintainers.i.name`_Optional ≝ `None`

Optional[str (AfterValidator(_remove_slashes))]

`training_data.maintainers.i.github_user`_str

`training_data.rdf_source`_Optional ≝ `None`

Resource description file (RDF) source; used to keep track of where an rdf.yaml was loaded from. Do not set this field in a YAML file.

Optional[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*]

Optional[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right')]

`training_data.tags`_{Sequence[str]} ≝ `[]`

Associated tags Example: ('unet2d', 'pytorch', 'nucleus', 'segmentation', 'dsb2018')

`training_data.version`_Optional ≝ `None`

The version of the resource following SemVer 2.0.

Optional[_internal.version_type.Version]

`training_data.version_number`_{Optional[int]} ≝ `None`

version number (n-th published version, not the semantic version)

`training_data.format_version`_{Literal[0.2.4]} ≝ `0.2.4`

The format version of this resource specification (not the version of the resource description) When creating a new resource always use the latest micro/patch version described here. The format_version is important for any consumer software to understand how to parse the fields.

`training_data.badges`_Sequence ≝ `[]`

badges associated with this resource

Sequence[generic.v0_2.BadgeDescr]

generic.v0_2.BadgeDescr:

`training_data.badges.i.label`_str

badge label to display on hover Example: 'Open in Colab'

`training_data.badges.i.icon`_Union ≝ `None`

badge icon Example: 'https://colab.research.google.com/assets/colab-badge.svg'

Union[Union[Path*, _internal.io.RelativeFilePath]*, _internal.url.HttpUrl, Url*, None]

Union of

Union[Path (PathType(path_type='file')), _internal.io.RelativeFilePath] (AfterValidator(wo_special_file_name); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'))
_internal.url.HttpUrl
Url (max_length=2083 allowed_schemes=['http', 'https'])
None

`training_data.badges.i.url`_{_internal.url.HttpUrl}

target URL Example: 'https://colab.research.google.com/github/HenriquesLab/ZeroCostDL4Mic/blob/master/Colab_notebooks/U-net_2D_ZeroCostDL4Mic.ipynb'

`training_data.documentation`_Optional ≝ `None`

∈📦 URL or relative path to a markdown file with additional documentation. The recommended documentation file name is README.md. An .md suffix is mandatory. Examples: ['https://github.com/raw/bioimage-io/spec-bioimage-io/main/example_descriptions/models/unet2d_nuclei_broad/README.md', '…']

Optional[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path*]*]

Optional[Union[_internal.url.HttpUrl, _internal.io.RelativeFilePath, Path (PathType(path_type='file'))] (union_mode='left_to_right'; AfterValidator(wo_special_file_name); PlainSerializer(func=<function _package at 0x7fa8ebee2340>, return_type=PydanticUndefined, when_used='unless-none'))]

`training_data.license`_Union ≝ `None`

A SPDX license identifier. We do not support custom license beyond the SPDX license list, if you need that please open a GitHub issue to discuss your intentions with the community. Examples: ['CC0-1.0', 'MIT', 'BSD-2-Clause']

Union[_internal.license_id.LicenseId, _internal.license_id.DeprecatedLicenseId, str, None]

`training_data.type`_{Literal[dataset]} ≝ `dataset`

`training_data.id`_{Optional[dataset.v0_2.DatasetId]} ≝ `None`

Model zoo (bioimage.io) wide, unique identifier (assigned by bioimage.io)

`training_data.source`_{Optional[_internal.url.HttpUrl]} ≝ `None`

"URL to the source of the dataset.

`uploader`_{Optional[generic.v0_2.Uploader]} ≝ `None`

The person who uploaded the model (e.g. to bioimage.io)

Optional[generic.v0_2.Uploader]

generic.v0_2.Uploader:

`uploader.email`_Email

Email

`uploader.name`_Optional ≝ `None`

name

Optional[str (AfterValidator(_remove_slashes))]

`version`_Optional ≝ `None`

The version of the resource following SemVer 2.0.

Optional[_internal.version_type.Version]

`version_number`_{Optional[int]} ≝ `None`

version number (n-th published version, not the semantic version)

Example values

`authors.i.orcid`

0000-0001-2345-6789

`documentation`

https://github.com/raw/bioimage-io/spec-bioimage-io/main/example_descriptions/models/unet2d_nuclei_broad/README.md
README.md

`inputs.i.shape`

(1, 512, 512, 1)
{'min': (1, 64, 64, 1), 'step': (0, 32, 32, 0)}

`inputs.i.preprocessing.i.kwargs.axes`

xy

`inputs.i.preprocessing.i.kwargs.axes`

xy

`inputs.i.preprocessing.i.kwargs.mean`

(1.1, 2.2, 3.3)

`inputs.i.preprocessing.i.kwargs.std`

(0.1, 0.2, 0.3)

`inputs.i.preprocessing.i.kwargs.axes`

xy

`license`

CC0-1.0
MIT
BSD-2-Clause

`outputs.i.postprocessing.i.kwargs.axes`

xy

`outputs.i.postprocessing.i.kwargs.axes`

xy

`outputs.i.postprocessing.i.kwargs.mean`

(1.1, 2.2, 3.3)

`outputs.i.postprocessing.i.kwargs.std`

(0.1, 0.2, 0.3)

`outputs.i.postprocessing.i.kwargs.axes`

xy

`outputs.i.postprocessing.i.kwargs.axes`

xy

`weights.keras_hdf5.authors.i.orcid`

0000-0001-2345-6789

`weights.keras_hdf5.dependencies`

conda:environment.yaml
maven:./pom.xml
pip:./requirements.txt

`weights.keras_hdf5.parent`

pytorch_state_dict

`weights.onnx.authors.i.orcid`

0000-0001-2345-6789

`weights.onnx.dependencies`

conda:environment.yaml
maven:./pom.xml
pip:./requirements.txt

`weights.onnx.parent`

pytorch_state_dict

`weights.pytorch_state_dict.authors.i.orcid`

0000-0001-2345-6789

`weights.pytorch_state_dict.dependencies`

conda:environment.yaml
maven:./pom.xml
pip:./requirements.txt

`weights.pytorch_state_dict.parent`

pytorch_state_dict

`weights.pytorch_state_dict.architecture`

my_function.py:MyNetworkClass
my_module.submodule.get_my_model

`weights.tensorflow_js.authors.i.orcid`

0000-0001-2345-6789

`weights.tensorflow_js.dependencies`

conda:environment.yaml
maven:./pom.xml
pip:./requirements.txt

`weights.tensorflow_js.parent`

pytorch_state_dict

`weights.tensorflow_saved_model_bundle.authors.i.orcid`

0000-0001-2345-6789

`weights.tensorflow_saved_model_bundle.dependencies`

conda:environment.yaml
maven:./pom.xml
pip:./requirements.txt

`weights.tensorflow_saved_model_bundle.parent`

pytorch_state_dict

`weights.torchscript.authors.i.orcid`

0000-0001-2345-6789

`weights.torchscript.dependencies`

conda:environment.yaml
maven:./pom.xml
pip:./requirements.txt

`weights.torchscript.parent`

pytorch_state_dict

`config`

{'bioimageio': {'my_custom_key': 3837283, 'another_key': {'nested': 'value'}}, 'imagej': {'macro_dir': 'path/to/macro/file'}}

`covers`

cover.png

`git_repo`

https://github.com/bioimage-io/spec-bioimage-io/tree/main/example_descriptions/models/unet2d_nuclei_broad

`links`

('ilastik/ilastik', 'deepimagej/deepimagej', 'zero/notebook_u-net_3d_zerocostdl4mic')

`maintainers.i.orcid`

0000-0001-2345-6789

`packaged_by.i.orcid`

0000-0001-2345-6789

`tags`

('unet2d', 'pytorch', 'nucleus', 'segmentation', 'dsb2018')

`training_data.covers`

cover.png

`training_data.authors.i.orcid`

0000-0001-2345-6789

`training_data.config`

{'bioimageio': {'my_custom_key': 3837283, 'another_key': {'nested': 'value'}}, 'imagej': {'macro_dir': 'path/to/macro/file'}}

`training_data.git_repo`

https://github.com/bioimage-io/spec-bioimage-io/tree/main/example_descriptions/models/unet2d_nuclei_broad

`training_data.links`

('ilastik/ilastik', 'deepimagej/deepimagej', 'zero/notebook_u-net_3d_zerocostdl4mic')

`training_data.maintainers.i.orcid`

0000-0001-2345-6789

`training_data.tags`

('unet2d', 'pytorch', 'nucleus', 'segmentation', 'dsb2018')

`training_data.badges.i.label`

Open in Colab

`training_data.badges.i.icon`

https://colab.research.google.com/assets/colab-badge.svg

`training_data.badges.i.url`

https://colab.research.google.com/github/HenriquesLab/ZeroCostDL4Mic/blob/master/Colab_notebooks/U-net_2D_ZeroCostDL4Mic.ipynb

`training_data.documentation`

https://github.com/raw/bioimage-io/spec-bioimage-io/main/example_descriptions/models/unet2d_nuclei_broad/README.md
README.md

`training_data.license`

CC0-1.0
MIT
BSD-2-Clause

Files

model_descr_v0-4.md

Latest commit

History

model_descr_v0-4.md

File metadata and controls

bioimage.io model specification

type Literal[model] ≝ model

format_version Literal[0.4.10] ≝ 0.4.10

authors Sequence[generic.v0_2.Author]

authors.i.affiliation Optional[str] ≝ None

authors.i.email Optional[Email] ≝ None

authors.i.orcid Optional ≝ None

authors.i.name str

authors.i.github_user Optional[str] ≝ None

description str

documentation Union

inputs Sequence[InputTensorDescr]

inputs.i.name TensorName

inputs.i.description str ≝ ``

inputs.i.axes str

inputs.i.data_range Optional ≝ None

inputs.i.data_type Literal[float32, uint8, uint16]

inputs.i.shape Union

inputs.i.shape.min Sequence[int]

inputs.i.shape.step Sequence[int]

inputs.i.preprocessing Sequence ≝ []

inputs.i.preprocessing.i.name Literal[binarize] ≝ binarize

inputs.i.preprocessing.i.kwargs BinarizeKwargs

inputs.i.preprocessing.i.kwargs.threshold float

inputs.i.preprocessing.i.name Literal[clip] ≝ clip

inputs.i.preprocessing.i.kwargs ClipKwargs

inputs.i.preprocessing.i.kwargs.min float

inputs.i.preprocessing.i.kwargs.max float

inputs.i.preprocessing.i.name Literal[scale_linear] ≝ scale_linear

inputs.i.preprocessing.i.kwargs ScaleLinearKwargs

inputs.i.preprocessing.i.kwargs.axes Optional ≝ None

inputs.i.preprocessing.i.kwargs.gain Union[float, Sequence[float]] ≝ 1.0

inputs.i.preprocessing.i.kwargs.offset Union[float, Sequence[float]] ≝ 0.0

inputs.i.preprocessing.i.name Literal[sigmoid] ≝ sigmoid

inputs.i.preprocessing.i.name Literal[zero_mean_unit_variance] ≝ zero_mean_unit_variance

inputs.i.preprocessing.i.kwargs ZeroMeanUnitVarianceKwargs

inputs.i.preprocessing.i.kwargs.mode Literal ≝ fixed

inputs.i.preprocessing.i.kwargs.axes str

inputs.i.preprocessing.i.kwargs.mean Union ≝ None

inputs.i.preprocessing.i.kwargs.std Union ≝ None

inputs.i.preprocessing.i.kwargs.eps float ≝ 1e-06

inputs.i.preprocessing.i.name Literal[scale_range] ≝ scale_range

inputs.i.preprocessing.i.kwargs ScaleRangeKwargs

inputs.i.preprocessing.i.kwargs.mode Literal[per_dataset, per_sample]

inputs.i.preprocessing.i.kwargs.axes str

inputs.i.preprocessing.i.kwargs.min_percentile Union[int, float] ≝ 0.0

inputs.i.preprocessing.i.kwargs.max_percentile Union[int, float] ≝ 100.0

inputs.i.preprocessing.i.kwargs.eps float ≝ 1e-06

inputs.i.preprocessing.i.kwargs.reference_tensor Optional[TensorName] ≝ None

license Union

name str

outputs Sequence[OutputTensorDescr]

outputs.i.name TensorName

outputs.i.description str ≝ ``

outputs.i.axes str

outputs.i.data_range Optional ≝ None

outputs.i.data_type Literal

outputs.i.shape Union

outputs.i.shape.reference_tensor TensorName

outputs.i.shape.scale Sequence[Optional[float]]

outputs.i.shape.offset Sequence

outputs.i.halo Optional[Sequence[int]] ≝ None

outputs.i.postprocessing Sequence ≝ []

outputs.i.postprocessing.i.name Literal[binarize] ≝ binarize

outputs.i.postprocessing.i.kwargs BinarizeKwargs

outputs.i.postprocessing.i.kwargs.threshold float

outputs.i.postprocessing.i.name Literal[clip] ≝ clip

outputs.i.postprocessing.i.kwargs ClipKwargs

outputs.i.postprocessing.i.kwargs.min float

outputs.i.postprocessing.i.kwargs.max float

outputs.i.postprocessing.i.name Literal[scale_linear] ≝ scale_linear

outputs.i.postprocessing.i.kwargs ScaleLinearKwargs

outputs.i.postprocessing.i.kwargs.axes Optional ≝ None

outputs.i.postprocessing.i.kwargs.gain Union[float, Sequence[float]] ≝ 1.0

`type`_{Literal[model]} ≝ `model`

`format_version`_{Literal[0.4.10]} ≝ `0.4.10`

`authors`_{Sequence[generic.v0_2.Author]}

`authors.i.affiliation`_{Optional[str]} ≝ `None`

`authors.i.email`_{Optional[Email]} ≝ `None`

`authors.i.orcid`_Optional ≝ `None`

`authors.i.name`_str

`authors.i.github_user`_{Optional[str]} ≝ `None`

`description`_str

`documentation`_Union

`inputs`_{Sequence[InputTensorDescr]}

`inputs.i.name`_TensorName

`inputs.i.description`_str ≝ ``

`inputs.i.axes`_str

`inputs.i.data_range`_Optional ≝ `None`

`inputs.i.data_type`_{Literal[float32, uint8, uint16]}

`inputs.i.shape`_Union

`inputs.i.shape.min`_{Sequence[int]}

`inputs.i.shape.step`_{Sequence[int]}

`inputs.i.preprocessing`_Sequence ≝ `[]`

`inputs.i.preprocessing.i.name`_{Literal[binarize]} ≝ `binarize`

`inputs.i.preprocessing.i.kwargs`_{BinarizeKwargs}

`inputs.i.preprocessing.i.kwargs.threshold`_float

`inputs.i.preprocessing.i.name`_{Literal[clip]} ≝ `clip`

`inputs.i.preprocessing.i.kwargs`_ClipKwargs

`inputs.i.preprocessing.i.kwargs.min`_float

`inputs.i.preprocessing.i.kwargs.max`_float

`inputs.i.preprocessing.i.name`_{Literal[scale_linear]} ≝ `scale_linear`

`inputs.i.preprocessing.i.kwargs`_{ScaleLinearKwargs}

`inputs.i.preprocessing.i.kwargs.axes`_Optional ≝ `None`

`inputs.i.preprocessing.i.kwargs.gain`_{Union[float, Sequence[float]]} ≝ `1.0`

`inputs.i.preprocessing.i.kwargs.offset`_{Union[float, Sequence[float]]} ≝ `0.0`

`inputs.i.preprocessing.i.name`_{Literal[sigmoid]} ≝ `sigmoid`

`inputs.i.preprocessing.i.name`_{Literal[zero_mean_unit_variance]} ≝ `zero_mean_unit_variance`

`inputs.i.preprocessing.i.kwargs`_{ZeroMeanUnitVarianceKwargs}

`inputs.i.preprocessing.i.kwargs.mode`_Literal ≝ `fixed`

`inputs.i.preprocessing.i.kwargs.axes`_str

`inputs.i.preprocessing.i.kwargs.mean`_Union ≝ `None`

`inputs.i.preprocessing.i.kwargs.std`_Union ≝ `None`

`inputs.i.preprocessing.i.kwargs.eps`_float ≝ `1e-06`

`inputs.i.preprocessing.i.name`_{Literal[scale_range]} ≝ `scale_range`

`inputs.i.preprocessing.i.kwargs`_{ScaleRangeKwargs}

`inputs.i.preprocessing.i.kwargs.mode`_{Literal[per_dataset, per_sample]}

`inputs.i.preprocessing.i.kwargs.axes`_str

`inputs.i.preprocessing.i.kwargs.min_percentile`_{Union[int, float]} ≝ `0.0`

`inputs.i.preprocessing.i.kwargs.max_percentile`_{Union[int, float]} ≝ `100.0`

`inputs.i.preprocessing.i.kwargs.eps`_float ≝ `1e-06`

`inputs.i.preprocessing.i.kwargs.reference_tensor`_{Optional[TensorName]} ≝ `None`

`license`_Union

`name`_str

`outputs`_{Sequence[OutputTensorDescr]}

`outputs.i.name`_TensorName

`outputs.i.description`_str ≝ ``

`outputs.i.axes`_str

`outputs.i.data_range`_Optional ≝ `None`

`outputs.i.data_type`_Literal

`outputs.i.shape`_Union

`outputs.i.shape.reference_tensor`_TensorName

`outputs.i.shape.scale`_{Sequence[Optional[float]]}

`outputs.i.shape.offset`_Sequence

`outputs.i.halo`_{Optional[Sequence[int]]} ≝ `None`

`outputs.i.postprocessing`_Sequence ≝ `[]`

`outputs.i.postprocessing.i.name`_{Literal[binarize]} ≝ `binarize`

`outputs.i.postprocessing.i.kwargs`_{BinarizeKwargs}

`outputs.i.postprocessing.i.kwargs.threshold`_float

`outputs.i.postprocessing.i.name`_{Literal[clip]} ≝ `clip`

`outputs.i.postprocessing.i.kwargs`_ClipKwargs

`outputs.i.postprocessing.i.kwargs.min`_float

`outputs.i.postprocessing.i.kwargs.max`_float

`outputs.i.postprocessing.i.name`_{Literal[scale_linear]} ≝ `scale_linear`

`outputs.i.postprocessing.i.kwargs`_{ScaleLinearKwargs}

`outputs.i.postprocessing.i.kwargs.axes`_Optional ≝ `None`

`outputs.i.postprocessing.i.kwargs.gain`_{Union[float, Sequence[float]]} ≝ `1.0`

`outputs.i.postprocessing.i.kwargs.offset`_{Union[float, Sequence[float]]} ≝ `0.0`

`outputs.i.postprocessing.i.name`_{Literal[sigmoid]} ≝ `sigmoid`

`outputs.i.postprocessing.i.name`_{Literal[zero_mean_unit_variance]} ≝ `zero_mean_unit_variance`

`outputs.i.postprocessing.i.kwargs`_{ZeroMeanUnitVarianceKwargs}

`outputs.i.postprocessing.i.kwargs.mode`_Literal ≝ `fixed`

`outputs.i.postprocessing.i.kwargs.axes`_str

`outputs.i.postprocessing.i.kwargs.mean`_Union ≝ `None`