class_docstr: Dictionary version of RandSmoothDeform.
  
  The field is randomized once per invocation by default so the same field is applied to every selected key. The
  `field_mode` parameter specifying interpolation mode for the field can be a single value or a sequence of values
  with one for each key in `keys`. Similarly the `grid_mode` parameter can be one value or one per key.
  
  Args:
      keys: key names to apply the augment to
      spatial_size: input array size to which deformation grid is interpolated
      rand_size: size of the randomized field to start from
      pad: number of pixels/voxels along the edges of the field to pad with 0
      field_mode: interpolation mode to use when upsampling the deformation field
      align_corners: if True align the corners when upsampling field
      prob: probability transform is applied
      def_range: value of the deformation range in image size fractions
      grid_dtype: type for the deformation grid calculated from the field
      grid_mode: interpolation mode used for sampling input using deformation grid
      grid_padding_mode: padding mode used for sampling input using deformation grid
      grid_align_corners: if True align the corners when sampling the deformation grid
      device: Pytorch device to define field on
code: def __init__(
      self,
      keys: KeysCollection,
      spatial_size: Sequence[int],
      rand_size: Sequence[int],
      pad: int = 0,
      field_mode: SequenceStr = InterpolateMode.AREA,
      align_corners: bool | None = None,
      prob: float = 0.1,
      def_range: Sequence[float] | float = 1.0,
      grid_dtype=torch.float32,
      grid_mode: SequenceStr = GridSampleMode.NEAREST,
      grid_padding_mode: str = GridSamplePadMode.BORDER,
      grid_align_corners: bool | None = False,
      device: torch.device | None = None,
  ):
      RandomizableTransform.__init__(self, prob)
      MapTransform.__init__(self, keys)
  
      self.field_mode = ensure_tuple_rep(field_mode, len(self.keys))
      self.grid_mode = ensure_tuple_rep(grid_mode, len(self.keys))
  
      self.trans = RandSmoothDeform(
          rand_size=rand_size,
          spatial_size=spatial_size,
          pad=pad,
          field_mode=self.field_mode[0],
          align_corners=align_corners,
          prob=1.0,
          def_range=def_range,
          grid_dtype=grid_dtype,
          grid_mode=self.grid_mode[0],
          grid_padding_mode=grid_padding_mode,
          grid_align_corners=grid_align_corners,
          device=device,
      )
  
imports: from __future__ import annotations
  from collections.abc import Hashable, Mapping, Sequence
  from typing import Any
  import numpy
  import torch
  from monai.config import KeysCollection, SequenceStr
  from monai.config.type_definitions import NdarrayOrTensor
  from monai.data.meta_obj import get_track_meta
  from monai.transforms.smooth_field.array import RandSmoothDeform, RandSmoothFieldAdjustContrast, RandSmoothFieldAdjustIntensity
  from monai.transforms.transform import MapTransform, RandomizableTransform
  from monai.utils import GridSampleMode, GridSamplePadMode, InterpolateMode, convert_to_tensor, ensure_tuple_rep
label_desc: Use image node_id 1 to create a new RandSmoothDeformd object from inherited base classes: RandomizableTransform, MapTransform with example: obj = RandSmoothDeformd(keys, spatial_size, rand_size, pad, field_mode, align_corners, prob, def_range, grid_dtype, grid_mode, grid_padding_mode, grid_align_corners, device)