Coverage for src/bioimageio/core/proc_setup.py: 98%
147 statements
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-20 09:46 +0000
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-20 09:46 +0000
1from __future__ import annotations
3from collections.abc import Callable, Iterable, Mapping, Sequence
4from typing import (
5 NamedTuple,
6)
8from typing_extensions import assert_never
10from bioimageio.spec.model import AnyModelDescr, v0_4, v0_5
12from ._op_base import Operator
13from .digest_spec import get_member_id
14from .proc_ops import (
15 AddKnownDatasetStats,
16 EnsureDtype,
17 Processing,
18 UpdateStats,
19 get_proc,
20)
21from .sample import Sample
22from .stat_calculators import StatsCalculator, compute_dataset_measures
23from .stat_measures import (
24 DatasetMeasure,
25 DatasetMeasureBase,
26 Measure,
27 MeasureValue,
28 SampleMeasure,
29 SampleMeasureBase,
30)
32TensorDescr = (
33 v0_4.InputTensorDescr
34 | v0_4.OutputTensorDescr
35 | v0_5.InputTensorDescr
36 | v0_5.OutputTensorDescr
37)
40class PreAndPostprocessing(NamedTuple):
41 pre: list[Processing]
42 post: list[Processing]
45class _ProcessingCallables(NamedTuple):
46 pre: Callable[[Sample], None]
47 post: Callable[[Sample], None]
50class _ApplyProcs:
51 def __init__(self, procs: Sequence[Processing]):
52 super().__init__()
53 self._procs = procs
55 def __call__(self, sample: Sample) -> None:
56 for op in self._procs:
57 op(sample)
60def get_pre_and_postprocessing(
61 model: AnyModelDescr,
62 *,
63 dataset_for_initial_statistics: Iterable[Sample],
64 keep_updating_initial_dataset_stats: bool = False,
65 fixed_dataset_stats: Mapping[Measure, MeasureValue] | None = None,
66 dataset_fits_in_memory: bool = False,
67) -> _ProcessingCallables:
68 """Creates callables to apply pre- and postprocessing in-place to a sample"""
70 setup = setup_pre_and_postprocessing(
71 model=model,
72 dataset_for_initial_statistics=dataset_for_initial_statistics,
73 keep_updating_initial_dataset_stats=keep_updating_initial_dataset_stats,
74 fixed_dataset_stats=fixed_dataset_stats,
75 dataset_fits_in_memory=dataset_fits_in_memory,
76 )
77 return _ProcessingCallables(_ApplyProcs(setup.pre), _ApplyProcs(setup.post))
80def setup_pre_and_postprocessing(
81 model: AnyModelDescr,
82 dataset_for_initial_statistics: Iterable[Sample],
83 keep_updating_initial_dataset_stats: bool = False,
84 fixed_dataset_stats: Mapping[Measure, MeasureValue] | None = None,
85 dataset_fits_in_memory: bool = False,
86) -> PreAndPostprocessing:
87 """Get pre- and postprocessing operators for a `model` description.
89 Used in `bioimageio.core.create_prediction_pipeline
90 """
92 prep = _get_described_procs(model.inputs)
93 post = _get_described_procs(model.outputs, preceding_ops=prep)
94 prep_required = _get_required_measures(prep)
95 post_required = _get_required_measures(post) - prep_required
96 fixed_stats = fixed_dataset_stats or {}
98 stages: dict[tuple[Operator, ...], tuple[int, set[Measure]]] = {}
99 for i, proc in enumerate(prep):
100 for measure in proc.get_required_measures():
101 if measure in fixed_stats:
102 continue
103 applied_ops = measure.preceding_ops
104 if applied_ops in stages:
105 first_i, measures = stages[applied_ops]
106 measures.add(measure)
107 stages[applied_ops] = (min(first_i, i), measures)
108 else:
109 stages[applied_ops] = (i, {measure})
111 missing_post_stats = {
112 measure for measure in post_required if measure not in fixed_stats
113 }
114 initial_dataset_measures = {
115 measure
116 for _, measures in stages.values()
117 for measure in measures
118 if isinstance(measure, DatasetMeasureBase)
119 } | {
120 measure
121 for measure in missing_post_stats
122 if isinstance(measure, DatasetMeasureBase)
123 }
124 initial_dataset = (
125 list(dataset_for_initial_statistics) if initial_dataset_measures else []
126 )
128 fixed_stats_op = AddKnownDatasetStats(fixed_stats) if fixed_stats else None
129 initial_pre: list[Processing] = [] if fixed_stats_op is None else [fixed_stats_op]
130 pre: list[Processing] = list(initial_pre)
131 initial_stats: dict[Measure, MeasureValue] = {}
133 stages_by_index: dict[int, list[tuple[tuple[Operator, ...], set[Measure]]]] = {}
134 for applied_ops, (i, measures) in stages.items():
135 stages_by_index.setdefault(i, []).append((applied_ops, measures))
137 for i, proc in enumerate(prep):
138 for applied_ops, measures in stages_by_index.get(i, []):
139 dataset_measures = {
140 measure
141 for measure in measures
142 if isinstance(measure, DatasetMeasureBase)
143 }
144 if dataset_measures:
145 initial_stats_calc = StatsCalculator(
146 dataset_measures,
147 dataset_fits_in_memory=dataset_fits_in_memory,
148 )
149 for original_sample in initial_dataset:
150 sample = original_sample.copy(deep=False)
151 sample.stat = dict(sample.stat)
152 for op in initial_pre:
153 op(sample)
154 initial_stats_calc.update(sample)
156 stage_stats = initial_stats_calc.finalize()
157 missing_initial_dataset_stats = dataset_measures - stage_stats.keys()
158 if (
159 missing_initial_dataset_stats
160 and not keep_updating_initial_dataset_stats
161 ):
162 raise ValueError(
163 "Model requires dataset statistics that were not provided: "
164 + f"{missing_initial_dataset_stats}. Provide "
165 + "`dataset_for_initial_statistics` or "
166 + "`fixed_dataset_statistics`, or set "
167 + "`keep_updating_initial_dataset_statistics=True` to "
168 + "update them during prediction."
169 )
171 initial_stats.update(stage_stats.items())
173 runtime_stats = {
174 measure: value
175 for measure, value in {
176 **fixed_stats,
177 **initial_stats,
178 }.items()
179 if measure in measures and isinstance(measure, DatasetMeasureBase)
180 }
181 runtime_updater = UpdateStats(
182 StatsCalculator(
183 measures,
184 runtime_stats or None,
185 dataset_fits_in_memory=dataset_fits_in_memory,
186 ),
187 keep_updating_initial_dataset_stats=keep_updating_initial_dataset_stats,
188 )
189 pre.append(runtime_updater)
190 initial_pre.append(
191 UpdateStats(
192 StatsCalculator(
193 measures,
194 runtime_stats or None,
195 dataset_fits_in_memory=dataset_fits_in_memory,
196 ),
197 )
198 )
200 pre.append(proc)
201 initial_pre.append(proc)
203 if missing_post_stats:
204 post_dataset_measures = {
205 measure
206 for measure in missing_post_stats
207 if isinstance(measure, DatasetMeasureBase)
208 }
209 output_member_ids = {
210 get_member_id(tensor)
211 for tensor in model.outputs
212 if isinstance(tensor, (v0_4.OutputTensorDescr, v0_5.OutputTensorDescr))
213 }
214 output_dataset_measures = {
215 measure
216 for measure in post_dataset_measures
217 if measure.member_id in output_member_ids
218 }
219 if output_dataset_measures:
220 raise NotImplementedError(
221 "Dataset statistics on model outputs are not supported: "
222 + f"{output_dataset_measures}"
223 )
225 post_stats = compute_dataset_measures(
226 post_dataset_measures,
227 initial_dataset,
228 dataset_fits_in_memory=dataset_fits_in_memory,
229 initial_dataset_measures={
230 measure: value
231 for measure, value in {**fixed_stats, **initial_stats}.items()
232 if isinstance(measure, DatasetMeasureBase)
233 },
234 )
235 missing_initial_dataset_stats = post_dataset_measures - post_stats.keys()
236 if missing_initial_dataset_stats and not keep_updating_initial_dataset_stats: 236 ↛ 237line 236 didn't jump to line 237 because the condition on line 236 was never true
237 raise ValueError(
238 "Model requires dataset statistics that were not provided: "
239 + f"{missing_initial_dataset_stats}. Provide "
240 + "`dataset_for_initial_statistics` or `fixed_dataset_statistics`, "
241 + "or set `keep_updating_initial_dataset_statistics=True` to update "
242 + "them during prediction."
243 )
245 post_with_stats: list[Processing] = []
246 added: set[Measure] = set()
247 for proc in post:
248 required = (set(proc.get_required_measures()) & missing_post_stats) - added
249 by_applied_ops: dict[tuple[Operator, ...], set[Measure]] = {}
250 for measure in required:
251 by_applied_ops.setdefault(measure.preceding_ops, set()).add(measure)
252 for applied_ops, measures in by_applied_ops.items():
253 post_with_stats.append(
254 UpdateStats(
255 StatsCalculator(
256 measures,
257 {
258 measure: value
259 for measure, value in post_stats.items()
260 if measure in measures
261 },
262 dataset_fits_in_memory=dataset_fits_in_memory,
263 ),
264 keep_updating_initial_dataset_stats=keep_updating_initial_dataset_stats,
265 )
266 )
267 post_with_stats.append(proc)
268 added.update(required)
269 post = post_with_stats
271 return PreAndPostprocessing(pre, post)
274class RequiredMeasures(NamedTuple):
275 pre: set[Measure]
276 post: set[Measure]
279class RequiredDatasetMeasures(NamedTuple):
280 pre: set[DatasetMeasure]
281 post: set[DatasetMeasure]
284class RequiredSampleMeasures(NamedTuple):
285 pre: set[SampleMeasure]
286 post: set[SampleMeasure]
289def get_requried_measures(model: AnyModelDescr) -> RequiredMeasures:
290 pre = _get_described_procs(model.inputs)
291 post = _get_described_procs(model.outputs, preceding_ops=pre)
292 return RequiredMeasures(
293 _get_required_measures(pre),
294 _get_required_measures(post),
295 )
298def get_required_dataset_measures(model: AnyModelDescr) -> RequiredDatasetMeasures:
299 req = get_requried_measures(model)
300 return RequiredDatasetMeasures(
301 {m for m in req.pre if isinstance(m, DatasetMeasureBase)},
302 {m for m in req.post if isinstance(m, DatasetMeasureBase)},
303 )
306def get_requried_sample_measures(model: AnyModelDescr) -> RequiredSampleMeasures:
307 req = get_requried_measures(model)
308 return RequiredSampleMeasures(
309 {m for m in req.pre if isinstance(m, SampleMeasureBase)},
310 {m for m in req.post if isinstance(m, SampleMeasureBase)},
311 )
314def _get_described_procs(
315 tensor_descrs: Iterable[TensorDescr],
316 *,
317 preceding_ops: Sequence[Processing] = (),
318) -> list[Processing]:
319 tensor_descrs = list(tensor_descrs)
320 procs: list[Processing] = []
321 preceding_ops = list(preceding_ops)
323 def append(proc: Processing) -> None:
324 procs.append(proc)
325 preceding_ops.append(proc)
327 for t_descr in tensor_descrs:
328 first_proc = len(procs)
329 if isinstance(t_descr, (v0_4.InputTensorDescr, v0_4.OutputTensorDescr)):
330 member_id = get_member_id(t_descr)
331 append(
332 EnsureDtype(input=member_id, output=member_id, dtype=t_descr.data_type)
333 )
335 if isinstance(t_descr, (v0_4.InputTensorDescr, v0_5.InputTensorDescr)):
336 for proc_d in t_descr.preprocessing:
337 append(get_proc(proc_d, t_descr, preceding_ops=preceding_ops))
338 elif isinstance(t_descr, (v0_4.OutputTensorDescr, v0_5.OutputTensorDescr)):
339 for proc_d in t_descr.postprocessing:
340 append(get_proc(proc_d, t_descr, preceding_ops=preceding_ops))
341 else:
342 assert_never(t_descr)
344 if isinstance(t_descr, (v0_4.InputTensorDescr, v0_4.OutputTensorDescr)):
345 if len(procs) == first_proc + 1:
346 # remove initial ensure_dtype if there are no other proccessing steps
347 assert isinstance(procs[-1], EnsureDtype)
348 _ = procs.pop()
349 _ = preceding_ops.pop()
351 # ensure 0.4 models get float32 input
352 # which has been the implicit assumption for 0.4
353 member_id = get_member_id(t_descr)
354 append(EnsureDtype(input=member_id, output=member_id, dtype="float32"))
356 return procs
359def _get_required_measures(procs: Iterable[Processing]) -> set[Measure]:
360 return {measure for proc in procs for measure in proc.get_required_measures()}