Coverage for src/bioimageio/core/weight_converters/_utils_torch_onnx.py: 81%

95 statements  

« prev     ^ index     » next       coverage.py v7.17.3, created at 2026-11-20 09:46 +0000

1"""helper to export both TorchScript or PytorchStateDict to ONNX""" 

2 

3from __future__ import annotations 

4 

5from collections import defaultdict 

6from collections.abc import Sequence 

7from itertools import chain 

8from pathlib import Path 

9from typing import ( 

10 TYPE_CHECKING, 

11 Literal, 

12 Union, 

13) 

14 

15import torch 

16from loguru import logger 

17from torch.export import ExportedProgram 

18from typing_extensions import assert_never 

19 

20from bioimageio.spec.model.v0_5 import ( 

21 BatchAxis, 

22 FileDescr, 

23 InputAxis, 

24 ModelDescr, 

25 OnnxWeightsDescr, 

26 ParameterizedSize, 

27 SizeReference, 

28) 

29 

30from .. import __version__ 

31from ..backends.pytorch_backend import get_devices 

32from ..digest_spec import get_member_id, get_test_input_sample 

33from ..proc_setup import get_pre_and_postprocessing 

34 

35if TYPE_CHECKING: 

36 from torch.export.dynamic_shapes import ( 

37 _DimHint as DimHint, # pyright: ignore[reportPrivateUsage] 

38 ) 

39 

40 

41def get_torch_sample_inputs(model_descr: ModelDescr) -> tuple[torch.Tensor, ...]: 

42 sample = get_test_input_sample(model_descr) 

43 procs = get_pre_and_postprocessing( 

44 model_descr, dataset_for_initial_statistics=[sample] 

45 ) 

46 procs.pre(sample) 

47 inputs_numpy = [ 

48 sample.members[get_member_id(ipt)].to_numpy() for ipt in model_descr.inputs 

49 ] 

50 return tuple(torch.from_numpy(ipt) for ipt in inputs_numpy) 

51 

52 

53def _get_dynamic_axes_noop(model_descr: ModelDescr): 

54 """noop for dynamo=True which uses `get_dynamic_shapes` instead""" 

55 

56 return 

57 

58 

59def _get_dynamic_axes_impl(model_descr: ModelDescr): 

60 """dynamic axes for (old) onnx export with dynamo=False""" 

61 dynamic_axes: defaultdict[str, dict[int, str]] = defaultdict(dict) 

62 for d in chain(model_descr.inputs, model_descr.outputs): 

63 for i, ax in enumerate(d.axes): 

64 if not isinstance(ax.size, int): 

65 dynamic_axes[str(d.id)][i] = str(ax.id) 

66 

67 return dynamic_axes 

68 

69 

70try: 

71 from torch.export import Dim 

72 

73 STATIC_DIM = Dim.STATIC if hasattr(Dim, "STATIC") else None 

74 TensorDim = Union[Dim, "DimHint", None] 

75 

76except Exception as e: 

77 use_dynamo = False 

78 logger.info(f"Not using torch dynamo for ONNX export due to:\n{e}") 

79 

80 def _get_dynamic_shapes_noop(model_descr: ModelDescr): 

81 """noop for dynamo=False which uses `get_dynamic_axes` instead""" 

82 

83 return 

84 

85 get_dynamic_shapes = _get_dynamic_shapes_noop 

86 get_dynamic_axes = _get_dynamic_axes_impl 

87else: 

88 use_dynamo = True 

89 logger.info("Using torch dynamo for ONNX export") 

90 

91 def _get_dynamic_shapes_impl(model_descr: ModelDescr): 

92 """Get dynamic shapes for torch dynamo export""" 

93 # dynamic shapes as list to match the source code which may have 

94 # different arg names than the tensor ids in the model description 

95 

96 dynamic_shapes: list[dict[int, int | TensorDim]] = [] 

97 potential_ref_axes: dict[str, tuple[InputAxis, int]] = {} 

98 # add dynamic dims from parameterized input sizes (and fixed sizes as None) 

99 for d in model_descr.inputs: 

100 dynamic_tensor_dims: dict[int, int | TensorDim] = {} 

101 for i, ax in enumerate(d.axes): 

102 dim_name = f"{d.id}_{ax.id}" 

103 if isinstance(ax.size, int): 

104 dim = ax.size 

105 elif isinstance(ax, BatchAxis): 

106 dim = Dim("batch", min=1) 

107 elif isinstance(ax.size, ParameterizedSize): 107 ↛ 109line 107 didn't jump to line 109 because the condition on line 107 was always true

108 dim = Dim(dim_name, min=ax.size.min) 

109 elif isinstance(ax.size, SizeReference): 

110 continue # handled below 

111 else: 

112 assert_never(ax.size) 

113 

114 dynamic_tensor_dims[i] = dim 

115 potential_ref_axes[dim_name] = (ax, i) 

116 

117 dynamic_shapes.append(dynamic_tensor_dims) 

118 

119 # add dynamic dims from size references 

120 for d, dynamic_tensor_dims in zip(model_descr.inputs, dynamic_shapes): 

121 for i, ax in enumerate(d.axes): 

122 if not isinstance(ax.size, SizeReference): 122 ↛ 125line 122 didn't jump to line 125 because the condition on line 122 was always true

123 continue # handled above 

124 

125 dim_name_ref = f"{ax.size.tensor_id}_{ax.size.axis_id}" 

126 ax_ref, i_ref = potential_ref_axes[dim_name_ref] 

127 dim_ref = dynamic_tensor_dims[i_ref] 

128 if isinstance(dim_ref, Dim): 

129 a = ax_ref.scale / ax.scale 

130 b = ax.size.offset 

131 dim = a * dim_ref + b 

132 else: 

133 dim = STATIC_DIM 

134 

135 dynamic_tensor_dims[i] = dim 

136 

137 return dynamic_shapes 

138 

139 get_dynamic_shapes = _get_dynamic_shapes_impl 

140 get_dynamic_axes = _get_dynamic_axes_noop 

141 

142 

143def export_to_onnx( 

144 model_descr: ModelDescr, 

145 model: ExportedProgram | torch.nn.Module, 

146 output_path: Path, 

147 verbose: bool, 

148 opset_version: int, 

149 parent: Literal["torchscript", "pytorch_state_dict"], 

150 devices: Sequence[str | torch.device] | None = None, 

151) -> OnnxWeightsDescr: 

152 inputs_torch = get_torch_sample_inputs( 

153 model_descr 

154 ) # TODO: be more thorough about the device? 

155 devices = get_devices(devices) 

156 inputs_torch = tuple(t.to(devices[0]) for t in inputs_torch) 

157 # legacy TorchScript export until dynamo preserves dynamic interpolation. 

158 dynamo = use_dynamo and parent != "torchscript" 

159 save_weights_externally = dynamo 

160 with torch.no_grad(): 

161 outputs_original_torch = ( 

162 model.module()(*inputs_torch) 

163 if isinstance(model, ExportedProgram) 

164 else model(*inputs_torch) 

165 ) 

166 if isinstance(outputs_original_torch, torch.Tensor): 

167 outputs_original_torch = [outputs_original_torch] 

168 

169 _ = torch.onnx.export( 

170 model, 

171 inputs_torch, 

172 str(output_path), 

173 dynamo=dynamo, 

174 external_data=save_weights_externally, 

175 input_names=[str(d.id) for d in model_descr.inputs], 

176 output_names=[str(d.id) for d in model_descr.outputs], 

177 dynamic_axes=( 

178 get_dynamic_axes(model_descr) 

179 if dynamo 

180 else _get_dynamic_axes_impl(model_descr) 

181 ), 

182 dynamic_shapes=get_dynamic_shapes(model_descr) if dynamo else None, 

183 verbose=verbose, 

184 opset_version=opset_version, 

185 ) 

186 

187 if save_weights_externally: 

188 external_data_path = output_path.with_suffix( 

189 output_path.suffix + ".data" 

190 ).absolute() 

191 if not external_data_path.exists(): 191 ↛ 192line 191 didn't jump to line 192 because the condition on line 191 was never true

192 raise FileNotFoundError( 

193 f"Expected external data file at {external_data_path} not found." 

194 ) 

195 external_data_descr = FileDescr(source=external_data_path) 

196 else: 

197 external_data_descr = None 

198 

199 return OnnxWeightsDescr( 

200 source=output_path.absolute(), 

201 external_data=external_data_descr, 

202 parent=parent, 

203 opset_version=opset_version, 

204 comment=f"Converted with bioimageio.core {__version__}, dynamo={dynamo}.", 

205 )