phaserEM 0.1__py3-none-any.whl

phaser/execute.py

@@ -0,0 +1,371 @@
+import dataclasses
+import logging
+import time
+import typing as t
+
+import numpy
+import pane
+
+from phaser.utils.num import cast_array_module, get_backend_module, xp_is_jax, Sampling, to_complex_dtype
+from phaser.utils.object import ObjectSampling
+from .hooks import Hook, ObjectHook, RawData
+from .plan import GradientEnginePlan, ReconsPlan, EnginePlan, ScanHook, ProbeHook
+from .state import Patterns, ReconsState, PartialReconsState, IterState, ProgressState
+
+
+class Observer:
+    def __init__(self):
+        self.solver_start_time: t.Optional[float] = None
+        self.iter_start_time: t.Optional[float] = None
+        self.engine_i: int = 0
+        self.start_iter: int = 0
+
+    def _format_hhmmss(self, seconds: float) -> str:
+        hh, ss = divmod(seconds, (60 * 60))
+        mm, ss = divmod(ss, 60)
+        return f"{int(hh):02d}:{int(mm):02d}:{ss:06.3f}"
+
+    def _format_mmss(self, seconds: float) -> str:
+        mm, ss = divmod(seconds, 60)
+        return f"{int(mm):02d}:{ss:06.3f}"
+
+    def init_solver(self, init_state: ReconsState, engine_i: int):
+        self.engine_i = engine_i
+        self.start_iter = init_state.iter.total_iter
+
+        init_state.iter = IterState(self.engine_i, 1, self.start_iter + 1)
+
+    def start_solver(self):
+        logging.info("Engine initialized")
+        self.iter_start_time = self.solver_start_time = time.monotonic()
+
+    def heartbeat(self):
+        pass
+
+    def update_group(self, state: t.Union[ReconsState, PartialReconsState], force: bool = False):
+        pass
+
+    def update_iteration(self, state: t.Union[ReconsState, PartialReconsState], i: int, n: int, error: t.Optional[float] = None):
+        finish_time = time.monotonic()
+
+        if self.iter_start_time is not None:
+            delta = finish_time - self.iter_start_time
+            time_s = f" [{self._format_mmss(delta)}]"
+        else:
+            time_s = ""
+
+        w = len(str(n))
+
+        error_s = f" Error: {error:.3e}" if error is not None else ""
+        logging.info(f"Finished iter {i:{w}}/{n}{time_s}{error_s}")
+
+        state.iter = IterState(self.engine_i, i + 1, self.start_iter + i + 1)
+        self.iter_start_time = finish_time
+
+    def finish_solver(self):
+        logging.info("Solver finished!")
+        if self.solver_start_time is not None:
+            finish_time = time.monotonic()
+            delta = finish_time - self.solver_start_time
+            logging.info(f"Total time: {self._format_hhmmss(delta)}")
+
+
+def execute_plan(plan: ReconsPlan, observer: t.Optional[Observer] = None):
+    xp = get_backend_module(plan.backend)
+
+    if observer is None:
+        observer = Observer()
+
+    patterns, state = initialize_reconstruction(plan, xp)
+    dtype = patterns.patterns.dtype
+
+    for (engine_i, engine) in enumerate(plan.engines):
+        logging.info(f"Preparing for engine #{engine_i + 1}...")
+        patterns, state = prepare_for_engine(patterns, state, xp, t.cast(EnginePlan, engine.props))
+        state = engine({
+            'data': patterns,
+            'state': state,
+            'dtype': dtype,
+            'xp': xp,
+            'recons_name': plan.name,
+            'engine_i': engine_i,
+            'observer': observer,
+            'seed': None,
+        })
+
+    logging.info("Reconstruction finished!")
+
+
+def load_raw_data(
+    plan: ReconsPlan, xp: t.Any, seed: t.Any = None,
+    init_state: t.Union[ReconsState, PartialReconsState, None] = None
+) -> RawData:
+    dtype: type = numpy.float32 if plan.dtype == 'float32' else numpy.float64
+
+    raw_data = plan.raw_data(None)
+
+    wavelength = plan.wavelength or raw_data['wavelength']
+    if wavelength is None:
+        raise ValueError("`wavelength` must be specified by raw_data or manually")
+
+    if init_state is None:
+        init_state = PartialReconsState()
+
+    if init_state.wavelength is not None and not numpy.isclose(init_state.wavelength, wavelength):
+        logging.warning(f"Wavelength of reconstruction ({wavelength:.2e}) doesn't match wavelength " \
+                        f"of previous state ({init_state.wavelength:.2e})")
+
+    raw_data['scan_hook'] = pane.into_data(merge(  # type: ignore
+        pane.from_data(t.cast(dict, raw_data['scan_hook']), ScanHook) if raw_data['scan_hook'] is not None else None,
+        _MISSING if plan.init.scan in (None, {}) else plan.init.scan
+    ))
+    raw_data['probe_hook'] = pane.into_data(merge(  # type: ignore
+        pane.from_data(t.cast(dict, raw_data['probe_hook']), ProbeHook) if raw_data['probe_hook'] is not None else None,
+        _MISSING if plan.init.probe in (None, {}) else plan.init.probe
+    ))
+    #print(f"scan_hook: {raw_data['scan_hook']}")
+    #print(f"probe_hook: {raw_data['probe_hook']}")
+
+    if raw_data['scan_hook'] is None and init_state.scan is None:
+        raise ValueError("`scan` must be specified by raw data, previous state, or manually in `init.scan`")
+    if raw_data['probe_hook'] is None and init_state.probe is None:
+        raise ValueError("`probe` must be specified by raw data, previous state, or manually in `init.probe`")
+    if raw_data['scan_hook'] == {}:
+        raise ValueError("Manual `init.scan` specified to override initial state, but scan was not provided by the raw data")
+    if raw_data['probe_hook'] == {}:
+        raise ValueError("Manual `init.probe` specified to override initial state, but probe was not provided by the raw data")
+
+    raw_data['wavelength'] = wavelength
+    raw_data['seed'] = seed
+
+    # normalize pattern intensity
+    #raw_data['patterns'] /= numpy.mean(numpy.sum(raw_data['patterns'], axis=(-1, -2)))
+    # ensure raw data is of the correct type
+    if raw_data['patterns'].dtype != dtype:
+        raw_data['patterns'] = raw_data['patterns'].astype(dtype)
+
+    # process post_load hooks:
+    for p in plan.post_load:
+        raw_data = p(raw_data)
+
+    # materialize memmap
+    if isinstance(raw_data['patterns'], numpy.memmap):
+        raw_data['patterns'] = raw_data['patterns'].copy()
+
+    return raw_data
+
+
+def initialize_reconstruction(
+    plan: ReconsPlan, xp: t.Any, seed: t.Any = None,
+    init_state: t.Union[ReconsState, PartialReconsState, None] = None
+) -> t.Tuple[Patterns, ReconsState]:
+    xp = cast_array_module(xp)
+
+    logging.basicConfig(level=logging.INFO)
+
+    logging.info("Executing plan...")
+
+    dtype: t.Type[numpy.floating] = numpy.float32 if plan.dtype == 'float32' else numpy.float64
+    cdtype: t.Type[numpy.complexfloating] = to_complex_dtype(dtype)
+
+    logging.info(f"dtype: {dtype} array backend: {xp.__name__}")
+    if xp_is_jax(xp):
+        import jax
+        logging.info(f"jax backend: {jax.default_backend()} devices: {jax.devices()}")
+
+    if init_state is None:
+        if plan.init.state is not None:
+            path = plan.init.state.expanduser()
+            logging.info(f"Loading inital state from '{path}'...")
+            init_state = PartialReconsState.read_hdf5(path)
+        else:
+            init_state = PartialReconsState()
+
+    raw_data = load_raw_data(plan, xp, seed, init_state=init_state)
+
+    data = Patterns(raw_data['patterns'], raw_data['mask'])
+    sampling = raw_data['sampling']
+    wavelength = t.cast(float, raw_data['wavelength'])
+    probe_hook = raw_data['probe_hook']
+    scan_hook = raw_data['scan_hook']
+    del raw_data
+
+    if init_state.probe is not None and plan.init.probe is None:
+        logging.info("Re-using probe from initial state...")
+        probe = init_state.probe
+        probe.data = probe.data.astype(cdtype)
+
+        if probe.sampling != sampling:
+            logging.info("Resampling patterns to probe from initial state...")
+            data.patterns = sampling.resample_recip(data.patterns, probe.sampling)
+            data.pattern_mask = sampling.resample_recip(data.pattern_mask, probe.sampling)
+            sampling = probe.sampling
+
+    else:
+        logging.info("Initializing probe...")
+        probe = pane.from_data(probe_hook, ProbeHook)(  # type: ignore
+            {'sampling': sampling, 'wavelength': wavelength, 'dtype': dtype, 'seed': seed, 'xp': xp}
+        )
+    if probe.data.ndim == 2:
+        probe.data = probe.data.reshape((1, *probe.data.shape))
+
+    if init_state.scan is not None and plan.init.scan is None:
+        logging.info("Re-using scan from initial state...")
+        scan = init_state.scan
+    else:
+        logging.info("Initializing scan...")
+        scan = pane.from_data(scan_hook, ScanHook)(  # type: ignore
+            {'dtype': dtype, 'seed': seed, 'xp': xp}
+        )
+
+    obj_pad_px: float = plan.engines[0].obj_pad_px if len(plan.engines) > 0 else 5.0  # type: ignore
+    obj_sampling = ObjectSampling.from_scan(
+        scan, sampling.sampling, sampling.extent / 2. + obj_pad_px * sampling.sampling
+    )
+
+    if init_state.object is not None and plan.init.object is None:
+        logging.info("Re-using object from initial state...")
+        obj = init_state.object
+        obj.data = obj.data.astype(cdtype)
+    else:
+        logging.info("Initializing object...")
+        obj = (plan.init.object or pane.from_data('random', ObjectHook))({
+            'sampling': obj_sampling, 'slices': plan.slices, 'wavelength': wavelength,
+            'dtype': dtype, 'seed': seed, 'xp': xp
+        })
+    if obj.data.ndim == 2:
+        obj.data = obj.data.reshape((1, *obj.data.shape))
+        obj.thicknesses = numpy.array([], dtype=dtype)
+
+    state = ReconsState(
+        iter=IterState(0, 0, 0),
+        probe=probe,
+        object=obj,
+        scan=scan,
+        progress=ProgressState(iters=numpy.array([]), detector_errors=numpy.array([])),
+        wavelength=wavelength
+    )
+
+    # process post_init hooks
+    for p in plan.post_init:
+        (data, state) = p({
+            'data': data, 'state': state,
+            'dtype': dtype, 'seed': seed, 'xp': xp
+        })
+
+    # perform some checks on preprocessed data
+
+    if state.scan.shape[:-1] != data.patterns.shape[:-2]:
+        n_pos = int(numpy.prod(state.scan.shape[:-1]))
+        n_pat = int(numpy.prod(data.patterns.shape[:-2]))
+        if n_pos != n_pat:
+            raise ValueError(f"# of scan positions {n_pos} doesn't match # of patterns {n_pat}")
+
+        # reshape patterns to match scan
+        data.patterns = data.patterns.reshape((*state.scan.shape[:-1], *data.patterns.shape[-2:]))
+
+    avg_pattern_intensity = float(numpy.nanmean(numpy.nansum(data.patterns, axis=(-1, -2))))
+
+    if avg_pattern_intensity < 5.0:
+        logging.warning(
+            f"Mean pattern intensity is very low ({avg_pattern_intensity} particles). "
+            "Ensure that it is being scaled correctly to units of electrons/photons. "
+            "For simulated data, use the 'scale' or 'poisson' preprocessing"
+        )
+
+    return (data, state)
+
+
+def prepare_for_engine(patterns: Patterns, state: ReconsState, xp: t.Any, engine: EnginePlan) -> t.Tuple[Patterns, ReconsState]:
+    # TODO: more graceful
+    if isinstance(engine, GradientEnginePlan) and not xp_is_jax(xp):
+        raise ValueError("The gradient descent engine requires the jax backend.")
+
+    state = state.to_xp(xp)
+
+    if engine.sim_shape is not None and engine.sim_shape != state.probe.data.shape[-2:]:
+        if engine.resize_method == 'pad_crop':
+            new_sampling = Sampling(engine.sim_shape, extent=tuple(state.probe.sampling.extent))
+        else:
+            new_sampling = Sampling(engine.sim_shape, sampling=tuple(state.probe.sampling.sampling))
+
+        logging.info(f"Resampling probe and patterns to shape {new_sampling.shape}...")
+        state.probe.data = state.probe.sampling.resample(state.probe.data, new_sampling)
+        # also resample patterns
+        patterns.patterns = state.probe.sampling.resample_recip(patterns.patterns, new_sampling)
+        # and pattern mask
+        patterns.pattern_mask = state.probe.sampling.resample_recip(patterns.pattern_mask, new_sampling)
+
+        state.probe.sampling = new_sampling
+
+    obj_sampling = state.object.sampling
+
+    if not numpy.allclose(state.probe.sampling.sampling, state.object.sampling.sampling):
+        # resample object -> probe
+        logging.info(f"Resampling object to pixel size {list(map(float, state.probe.sampling.sampling))}...")
+        obj_sampling = obj_sampling.with_sampling(state.probe.sampling.sampling)
+
+    obj_sampling_pad = obj_sampling.expand_to_scan(
+        state.scan, state.probe.sampling.extent / 2. + engine.obj_pad_px * state.probe.sampling.sampling
+    )
+
+    if obj_sampling_pad != obj_sampling:
+        logging.info(f"Padding object to shape {obj_sampling_pad.shape}")
+        obj_sampling = obj_sampling_pad
+
+    if obj_sampling != state.object.sampling:
+        state.object.data = state.object.sampling.resample(state.object.data, obj_sampling)
+        state.object.sampling = obj_sampling
+
+    current_probe_modes = state.probe.data.shape[0]
+    if engine.probe_modes != current_probe_modes:
+        # fix probe modes
+        if engine.probe_modes < current_probe_modes:
+            # TODO: redistribute intensity here
+            state.probe.data = state.probe.data[:engine.probe_modes]
+        else:
+            from phaser.utils.optics import make_hermetian_modes
+            if current_probe_modes != 1:
+                logging.info("Summing probe modes (in real-space) before recreating with different # of modes")
+
+            base_mode = xp.sum(state.probe.data, axis=0)
+            state.probe.data = make_hermetian_modes(base_mode, engine.probe_modes, base_mode_power=engine.base_mode_power)
+
+    if engine.slices is not None and (len(engine.slices.thicknesses) != len(state.object.thicknesses)
+                                      or not numpy.allclose(engine.slices.thicknesses, state.object.thicknesses)):
+        from phaser.utils.object import resample_slices
+        logging.info(f"Reslicing object from {max(1, len(state.object.thicknesses))} to {max(1, len(engine.slices.thicknesses))} slice(s)...")
+        state.object.data = resample_slices(state.object.data, state.object.thicknesses, engine.slices.thicknesses)
+        state.object.thicknesses = xp.array(engine.slices.thicknesses, dtype=state.object.thicknesses.dtype)
+
+    return patterns, state
+
+
+_MISSING = object()
+
+
+def merge(left: t.Any, right: t.Any) -> t.Any:
+    def _as_dict(val) -> t.Optional[dict]:
+        if isinstance(val, dict):
+            return val
+        if dataclasses.is_dataclass(val):
+            return dataclasses.asdict(val)  # type: ignore
+        if isinstance(val, pane.PaneBase):
+            return val.dict(set_only=True)
+        return None
+
+    if left is _MISSING or right is _MISSING:
+        return left if right is _MISSING else right
+
+    if isinstance(left, Hook) and isinstance(right, Hook):
+        if left.ref != right.ref:
+            return right
+        d = merge(left.props or {}, right.props or {})
+        d['type'] = right.type if right.type is not None else right.ref
+        return pane.from_data(d, right.__class__)
+
+    if (left_d := _as_dict(left)) is not None and (right_d := _as_dict(right)) is not None:
+        keys = set(left_d.keys()) | set(right_d.keys())
+        return {k: merge(left_d.get(k, _MISSING), right_d.get(k, _MISSING)) for k in keys}
+
+    return left if right is _MISSING else right

phaser/hooks/__init__.py

@@ -0,0 +1,158 @@
+from pathlib import Path
+import typing as t
+
+import numpy
+from numpy.typing import NDArray, DTypeLike
+import pane.annotations as annotations
+
+from ..types import Dataclass, Slices
+from .hook import Hook
+
+if t.TYPE_CHECKING:
+    from phaser.utils.num import Sampling
+    from phaser.utils.object import ObjectSampling
+    from ..state import ObjectState, ProbeState, ReconsState, Patterns
+    from ..execute import Observer
+
+
+class RawData(t.TypedDict):
+    patterns: NDArray[numpy.floating]
+    mask: NDArray[numpy.floating]
+    sampling: 'Sampling'
+    wavelength: t.Optional[float]
+    scan_hook: t.Union[t.Dict[str, t.Any], None]
+    probe_hook: t.Union[t.Dict[str, t.Any], None]
+    seed: t.Optional[object]
+
+
+class LoadEmpadProps(Dataclass):
+    path: Path
+
+    diff_step: t.Optional[float] = None
+    kv: t.Optional[float] = None
+    adu: t.Optional[float] = None
+
+
+class RawDataHook(Hook[None, RawData]):
+    known = {
+        'empad': ('phaser.hooks.io.empad:load_empad', LoadEmpadProps),
+    }
+
+
+class ProbeHookArgs(t.TypedDict):
+    sampling: 'Sampling'
+    wavelength: float
+    seed: t.Optional[object]
+    dtype: DTypeLike
+    xp: t.Any
+
+
+class FocusedProbeProps(Dataclass):
+    defocus: t.Optional[float] = None  # defocus, + is overfocus [A]
+    conv_angle: t.Optional[float] = None  # semiconvergence angle [mrad]
+
+
+class ProbeHook(Hook[ProbeHookArgs, 'ProbeState']):
+    known = {
+        'focused': ('phaser.hooks.probe:focused_probe', FocusedProbeProps),
+    }
+
+
+class ObjectHookArgs(t.TypedDict):
+    sampling: 'ObjectSampling'
+    wavelength: float
+    slices: t.Optional[Slices]
+    seed: t.Optional[object]
+    dtype: DTypeLike
+    xp: t.Any
+
+
+class RandomObjectProps(Dataclass):
+    sigma: float = 1e-6
+
+
+class ObjectHook(Hook[ObjectHookArgs, 'ObjectState']):
+    known = {
+        'random': ('phaser.hooks.object:random_object', RandomObjectProps),
+    }
+
+
+class ScanHookArgs(t.TypedDict):
+    seed: t.Optional[object]
+    dtype: DTypeLike
+    xp: t.Any
+
+
+class RasterScanProps(Dataclass):
+    shape: t.Optional[t.Tuple[int, int]] = None  # ny, nx (total shape)
+    step_size: t.Union[None, float, t.Tuple[float, float]] = None  # A
+    rotation: t.Optional[float] = None     # degrees CCW
+    affine: t.Optional[t.Annotated[NDArray[numpy.floating], annotations.shape((2, 2))]] = None
+
+
+class ScanHook(Hook[ScanHookArgs, NDArray[numpy.floating]]):
+    known = {
+        'raster': ('phaser.hooks.scan:raster_scan', RasterScanProps),
+    }
+
+
+class PostInitArgs(t.TypedDict):
+    data: 'Patterns'
+    state: 'ReconsState'
+    seed: t.Optional[object]
+    dtype: DTypeLike
+    xp: t.Any
+
+
+class ScaleProps(Dataclass):
+    scale: float
+
+
+class CropDataProps(Dataclass):
+    crop: t.Tuple[
+        # y_i, y_f, x_i, x_f
+        t.Optional[int], t.Optional[int], t.Optional[int], t.Optional[int],
+    ] 
+
+
+class PoissonProps(Dataclass):
+    scale: t.Optional[float] = None
+    gaussian: t.Optional[float] = 1.0e-3
+
+
+class DropNanProps(Dataclass):
+    threshold: float = 0.9
+
+
+class DiffractionAlignProps(Dataclass):
+    ...
+
+
+class PostLoadHook(Hook[RawData, RawData]):
+    known = {
+        'crop_data': ('phaser.hooks.preprocessing:crop_data', CropDataProps),
+        'poisson': ('phaser.hooks.preprocessing:add_poisson_noise', PoissonProps),
+        'scale': ('phaser.hooks.preprocessing:scale_patterns', ScaleProps),
+    }
+
+
+class PostInitHook(Hook[PostInitArgs, t.Tuple['Patterns', 'ReconsState']]):
+    known = {
+        'drop_nans': ('phaser.hooks.preprocessing:drop_nan_patterns', DropNanProps),
+        'diffraction_align': ('phaser.hooks.preprocessing:diffraction_align', DiffractionAlignProps),
+    }
+
+
+class EngineArgs(t.TypedDict):
+    data: 'Patterns'
+    state: 'ReconsState'
+    dtype: DTypeLike
+    xp: t.Any
+    recons_name: str
+    engine_i: int
+    observer: 'Observer'
+    seed: t.Any
+
+
+class EngineHook(Hook[EngineArgs, 'ReconsState']):
+    known = {}  # filled in by plan.py

phaser/hooks/hook.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import abc
+import importlib
+import typing as t
+
+import pane
+from pane.convert import ConverterHandlers, DataType
+from pane.converters import Converter, make_converter
+from pane.errors import ErrorNode, WrongTypeError, ParseInterrupt, ProductErrorNode
+
+T = t.TypeVar('T')
+U = t.TypeVar('U')
+
+class Hook(t.Generic[T, U], abc.ABC):
+    known: t.ClassVar[t.Dict[str, t.Tuple[str, type]]] = {}
+
+    def __init__(
+        self, ref: str, props: t.Optional[t.Any] = None, type: t.Optional[str] = None,
+    ):
+        self.ref: str = ref
+        self.type: t.Optional[str] = type
+        self.f: t.Optional[t.Callable[..., U]] = None
+        self.props: t.Optional[t.Any] = props
+
+    def func_ref(self) -> str:
+        if self.type is not None:
+            return self.type
+        return self.ref
+
+    def _resolve_ref(self) -> t.Callable:
+        if ':' not in self.ref:
+            if self.ref in globals():
+                return globals()[self.ref]
+            raise ValueError(f"Can't resolve function reference '{self.ref}'.")
+
+        (module_path, func_name) = self.ref.split(':')
+        try:
+            module = importlib.import_module(module_path)
+        except ImportError as e:
+            e.add_note(f"While resolving function reference {self.ref}")
+            raise
+
+        try:
+            return getattr(module, func_name)
+        except AttributeError:
+            raise AttributeError(f"No function '{func_name}' found in module '{module_path}'")
+
+    def resolve(self) -> t.Callable[..., U]:
+        if self.f is None:
+            self.f = self._resolve_ref()
+        return self.f
+
+    def __call__(self, args: T) -> U:
+        return self.resolve()(args, props=self.props if self.props is not None else {})
+
+    def __getattr__(self, key: t.Any) -> t.Any:
+        if isinstance(self.props, dict):
+            try:
+                return self.props[key]
+            except KeyError:
+                raise AttributeError(name=key, obj=self.props)
+        return getattr(self.props, key)
+
+    def __repr__(self) -> str:
+        if self.props is not None:
+            return f"FuncRef({self.func_ref()!r}, {self.props!r})"
+        return f"FuncRef({self.func_ref()!r})"
+
+    @classmethod
+    def _converter(cls, *args: type, handlers: ConverterHandlers) -> HookConverter[T, U]:
+        return HookConverter(cls, handlers)
+
+
+def _to_dict(val: t.Any) -> dict:
+    import dataclasses
+    import pane
+
+    if isinstance(val, dict):
+        return val
+    if dataclasses.is_dataclass(val):
+        return dataclasses.asdict(val)  # type: ignore
+    if isinstance(val, pane.PaneBase):
+        return val.into_data()         # type: ignore
+    return val.__dict__
+
+
+class HookConverter(t.Generic[T, U], Converter[Hook[T, U]]):
+    def __init__(self, cls: t.Type[Hook[T, U]], handlers: ConverterHandlers):
+        self.cls = cls
+        self.inner: Converter[t.Union[str, t.Dict[str, t.Any]]] = make_converter(t.Union[str, t.Dict[str, t.Any]], handlers)
+
+    def expected(self, plural: bool = False) -> str:
+        if plural:
+            return "hooks to functions"
+        return "hook to function"
+
+    def into_data(self, val: Hook[T, U]) -> DataType:
+        if val.props is not None:
+            return {
+                'type': val.func_ref(),
+                **_to_dict(val.props)
+            }
+        return val.func_ref()
+
+    def try_convert(self, val: t.Any) -> Hook[T, U]:
+        val = self.inner.try_convert(val)
+        if isinstance(val, str):
+            ref = val
+            props = {}
+        else:
+            if 'type' not in val:
+                raise ParseInterrupt()
+            ref = str(val.pop('type'))
+            props = val
+
+        if ref in self.cls.known:
+            ty = ref
+            (ref, props_ty) = self.cls.known[ty]
+
+            converter = make_converter(props_ty)
+            props = converter.try_convert(props)
+        elif ':' not in ref:
+            raise ParseInterrupt()
+        else:
+            ty = None
+
+        return self.cls(ref, props, ty)
+
+    def collect_errors(self, val: t.Any) -> t.Optional[ErrorNode]:
+        try:
+            val = self.inner.try_convert(val)
+        except ParseInterrupt:
+            return self.inner.collect_errors(val)
+        if isinstance(val, str):
+            ref = val
+            props = {}
+        else:
+            if 'type' not in val:
+                return ProductErrorNode(self.expected(), {}, val, set(['type']))
+            ref = str(val.pop('type'))
+            props = val
+
+        if ref in self.cls.known:
+            ty = ref
+            (ref, props_ty) = self.cls.known[ty]
+
+            converter = make_converter(props_ty)
+            try:
+                props = converter.try_convert(props)
+            except ParseInterrupt:
+                return converter.collect_errors(props)
+        elif ':' not in ref:
+            return WrongTypeError(
+                self.expected(), ref,
+                info=f"Known hooks: '{', '.join(self.cls.known.keys())}'"
+            )
+
+        return None