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

1from __future__ import annotations 

2 

3from collections.abc import Callable, Iterable, Mapping, Sequence 

4from typing import ( 

5 NamedTuple, 

6) 

7 

8from typing_extensions import assert_never 

9 

10from bioimageio.spec.model import AnyModelDescr, v0_4, v0_5 

11 

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) 

31 

32TensorDescr = ( 

33 v0_4.InputTensorDescr 

34 | v0_4.OutputTensorDescr 

35 | v0_5.InputTensorDescr 

36 | v0_5.OutputTensorDescr 

37) 

38 

39 

40class PreAndPostprocessing(NamedTuple): 

41 pre: list[Processing] 

42 post: list[Processing] 

43 

44 

45class _ProcessingCallables(NamedTuple): 

46 pre: Callable[[Sample], None] 

47 post: Callable[[Sample], None] 

48 

49 

50class _ApplyProcs: 

51 def __init__(self, procs: Sequence[Processing]): 

52 super().__init__() 

53 self._procs = procs 

54 

55 def __call__(self, sample: Sample) -> None: 

56 for op in self._procs: 

57 op(sample) 

58 

59 

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""" 

69 

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)) 

78 

79 

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. 

88 

89 Used in `bioimageio.core.create_prediction_pipeline 

90 """ 

91 

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 {} 

97 

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}) 

110 

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 ) 

127 

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] = {} 

132 

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)) 

136 

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) 

155 

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 ) 

170 

171 initial_stats.update(stage_stats.items()) 

172 

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 ) 

199 

200 pre.append(proc) 

201 initial_pre.append(proc) 

202 

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 ) 

224 

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 ) 

244 

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 

270 

271 return PreAndPostprocessing(pre, post) 

272 

273 

274class RequiredMeasures(NamedTuple): 

275 pre: set[Measure] 

276 post: set[Measure] 

277 

278 

279class RequiredDatasetMeasures(NamedTuple): 

280 pre: set[DatasetMeasure] 

281 post: set[DatasetMeasure] 

282 

283 

284class RequiredSampleMeasures(NamedTuple): 

285 pre: set[SampleMeasure] 

286 post: set[SampleMeasure] 

287 

288 

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 ) 

296 

297 

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 ) 

304 

305 

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 ) 

312 

313 

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) 

322 

323 def append(proc: Processing) -> None: 

324 procs.append(proc) 

325 preceding_ops.append(proc) 

326 

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 ) 

334 

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) 

343 

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() 

350 

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")) 

355 

356 return procs 

357 

358 

359def _get_required_measures(procs: Iterable[Processing]) -> set[Measure]: 

360 return {measure for proc in procs for measure in proc.get_required_measures()}