o  i"@sdZddlmZddlZddlmZmZmZmZm Z ddl m Z ddl m Z ddlZddlZddlmZddlmZmZmZdd lmZdd lmZdd lmZdd lmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)dd l*m+Z+ddl,m-Z-ddl.m/Z/m0Z0ddl1m2Z2m3Z3m4Z4m5Z5gdZ6e27Z8Gddde+Z9Gddde+Z:Gddde+Z;Gddde+ZGddde+Z?Gd d!d!e+Z@Gd"d#d#e@ZAGd$d%d%e@ZBGd&d'd'e+ZCGd(d)d)e+ZDGd*d+d+e+ZEGd,d-d-e+ZFGd.d/d/e+ZGe9ZHZIe:ZJZKe>ZLZMeDZNZOe;ZPZQe<ZRZSe=ZTZUe?ZVZWeAZXZYeCZZZ[eEZ\Z]eBZ^Z_e@Z`ZaeFZbZceGZdZedS)0z A collection of dictionary-based wrappers around the "vanilla" transforms for model output tensors defined in :py:class:`monai.transforms.utility.array`. Class names are ended with 'd' to denote dictionary-based transforms. ) annotationsN)CallableHashableIterableMappingSequence)deepcopy)Any)config)KeysCollectionNdarrayOrTensorPathLike)CSVSaver) MetaTensor)InvertibleTransform) Activations AsDiscreteDistanceTransformEDT FillHolesKeepLargestConnectedComponent LabelFilterLabelToContour MeanEnsembleProbNMSRemoveSmallObjectsSobelGradients VoteEnsemble) MapTransform)ToTensor)allow_missing_keys_modeconvert_applied_interp_mode)PostFixconvert_to_tensor ensure_tupleensure_tuple_rep)- ActivationsDActivationsDict Activationsd AsDiscreteDAsDiscreteDict AsDiscreted Ensembled EnsembleD EnsembleDict FillHolesD FillHolesDict FillHolesdInvertD InvertDictInvertdKeepLargestConnectedComponentD!KeepLargestConnectedComponentDictKeepLargestConnectedComponentdRemoveSmallObjectsDRemoveSmallObjectsDictRemoveSmallObjectsd LabelFilterDLabelFilterDict LabelFilterdLabelToContourDLabelToContourDictLabelToContourd MeanEnsembleDMeanEnsembleDict MeanEnsembledProbNMSD ProbNMSDictProbNMSdSaveClassificationDSaveClassificationDictSaveClassificationdSobelGradientsDSobelGradientsDictSobelGradientsd VoteEnsembleDVoteEnsembleDict VoteEnsembledDistanceTransformEDTdDistanceTransformEDTDDistanceTransformEDTDictcs<eZdZdZejZ    ddfdd ZdddZZS)r'z Dictionary-based wrapper of :py:class:`monai.transforms.AddActivations`. Add activation layers to the input data specified by `keys`. FNkeysr sigmoidSequence[bool] | boolsoftmaxother$Sequence[Callable] | Callable | Noneallow_missing_keysboolreturnNonec sXt||t|t|j|_t|t|j|_t|t|j|_t|_ ||j _ dS)a Args: keys: keys of the corresponding items to model output and label. See also: :py:class:`monai.transforms.compose.MapTransform` sigmoid: whether to execute sigmoid function on model output before transform. it also can be a sequence of bool, each element corresponds to a key in ``keys``. softmax: whether to execute softmax function on model output before transform. it also can be a sequence of bool, each element corresponds to a key in ``keys``. other: callable function to execute other activation layers, for example: `other = torch.tanh`. it also can be a sequence of Callable, each element corresponds to a key in ``keys``. allow_missing_keys: don't raise exception if key is missing. kwargs: additional parameters to `torch.softmax` (used when ``softmax=True``). Defaults to ``dim=0``, unrecognized parameters will be ignored. N) super__init__r$lenrRrSrUrVr converterkwargs)selfrRrSrUrVrXr` __class__b/home/dell461/cl/sdc2/last_ska_mid/HISourceFinder-master-l/src/monai/transforms/post/dictionary.pyr]os  zActivationsd.__init__data"Mapping[Hashable, NdarrayOrTensor]dict[Hashable, NdarrayOrTensor]cCsHt|}|||j|j|jD]\}}}}||||||||<q|SN)dict key_iteratorrSrUrVr_)rarfdkeyrSrUrVrdrdre__call__s"zActivationsd.__call__)FFNF) rRr rSrTrUrTrVrWrXrYrZr[rfrgrZrh) __name__ __module__ __qualname____doc__rbackendr]rn __classcell__rdrdrbrer'gs r'cs>eZdZdZejZ     ddfdd ZdddZZS)r*zN Dictionary-based wrapper of :py:class:`monai.transforms.AsDiscrete`. FNrRr argmaxrT to_onehot!Sequence[int | None] | int | None threshold%Sequence[float | None] | float | Nonerounding!Sequence[str | None] | str | NonerXrYrZr[c  st||t|t|j|_g|_t|t|jD]}t|tr&t d|j |qg|_ t|t|jD]}t|trCt d|j |q8t|t|j|_ t |_||j_dS)aa Args: keys: keys of the corresponding items to model output and label. See also: :py:class:`monai.transforms.compose.MapTransform` argmax: whether to execute argmax function on input data before transform. it also can be a sequence of bool, each element corresponds to a key in ``keys``. to_onehot: if not None, convert input data into the one-hot format with specified number of classes. defaults to ``None``. it also can be a sequence, each element corresponds to a key in ``keys``. threshold: if not None, threshold the float values to int number 0 or 1 with specified threshold value. defaults to ``None``. it also can be a sequence, each element corresponds to a key in ``keys``. rounding: if not None, round the data according to the specified option, available options: ["torchrounding"]. it also can be a sequence of str or None, each element corresponds to a key in ``keys``. allow_missing_keys: don't raise exception if key is missing. kwargs: additional parameters to ``AsDiscrete``. ``dim``, ``keepdim``, ``dtype`` are supported, unrecognized parameters will be ignored. These default to ``0``, ``True``, ``torch.float`` respectively. zQ`to_onehot=True/False` is deprecated, please use `to_onehot=num_classes` instead.zR`threshold_values=True/False` is deprecated, please use `threshold=value` instead.N)r\r]r$r^rRrvrw isinstancerY ValueErrorappendryr{rr_r`) rarRrvrwryr{rXr`flagrbrdrer]s   zAsDiscreted.__init__rfrgrhcCsPt|}|||j|j|j|jD]\}}}}}|||||||||<q|Sri)rjrkrvrwryr{r_)rarfrlrmrvrwryr{rdrdrerns zAsDiscreted.__call__)FNNNF)rRr rvrTrwrxryrzr{r|rXrYrZr[ro) rprqrrrsrrtr]rnrurdrdrbrer*s/r*cs@eZdZdZejZ      ddfdd ZdddZZS)r6za Dictionary-based wrapper of :py:class:`monai.transforms.KeepLargestConnectedComponent`. NTFrRr applied_labelsSequence[int] | int | None is_onehot bool | None independentrY connectivity int | Nonenum_componentsintrXrZr[cs&t||t|||||d|_dS)a  Args: keys: keys of the corresponding items to be transformed. See also: :py:class:`monai.transforms.compose.MapTransform` applied_labels: Labels for applying the connected component analysis on. If given, voxels whose value is in this list will be analyzed. If `None`, all non-zero values will be analyzed. is_onehot: if `True`, treat the input data as OneHot format data, otherwise, not OneHot format data. default to None, which treats multi-channel data as OneHot and single channel data as not OneHot. independent: whether to treat ``applied_labels`` as a union of foreground labels. If ``True``, the connected component analysis will be performed on each foreground label independently and return the intersection of the largest components. If ``False``, the analysis will be performed on the union of foreground labels. default is `True`. connectivity: Maximum number of orthogonal hops to consider a pixel/voxel as a neighbor. Accepted values are ranging from 1 to input.ndim. If ``None``, a full connectivity of ``input.ndim`` is used. for more details: https://scikit-image.org/docs/dev/api/skimage.measure.html#skimage.measure.label. num_components: The number of largest components to preserve. allow_missing_keys: don't raise exception if key is missing. )rrrrrN)r\r]rr_)rarRrrrrrrXrbrdrer]s  z'KeepLargestConnectedComponentd.__init__rfrgrhcC.t|}||D] }|||||<q |Srirjrkr_rarfrlrmrdrdrernz'KeepLargestConnectedComponentd.__call__)NNTNrF)rRr rrrrrrYrrrrrXrYrZr[ro) rprqrrrsrrtr]rnrurdrdrbrer6s)r6cs@eZdZdZejZ      ddfdd ZdddZZS)r9a Dictionary-based wrapper of :py:class:`monai.transforms.RemoveSmallObjectsd`. Args: min_size: objects smaller than this size (in number of voxels; or surface area/volume value in whatever units your image is if by_measure is True) are removed. connectivity: Maximum number of orthogonal hops to consider a pixel/voxel as a neighbor. Accepted values are ranging from 1 to input.ndim. If ``None``, a full connectivity of ``input.ndim`` is used. For more details refer to linked scikit-image documentation. independent_channels: Whether or not to consider channels as independent. If true, then conjoining islands from different labels will be removed if they are below the threshold. If false, the overall size islands made from all non-background voxels will be used. by_measure: Whether the specified min_size is in number of voxels. if this is True then min_size represents a surface area or volume value of whatever units your image is in (mm^3, cm^2, etc.) default is False. e.g. if min_size is 3, by_measure is True and the units of your data is mm, objects smaller than 3mm^3 are removed. pixdim: the pixdim of the input image. if a single number, this is used for all axes. If a sequence of numbers, the length of the sequence must be equal to the image dimensions. @rTFNrRr min_sizerrindependent_channelsrY by_measurepixdim+Sequence[float] | float | np.ndarray | NonerXrZr[cs$t||t||||||_dSri)r\r]rr_)rarRrrrrrrXrbrdrer]$s zRemoveSmallObjectsd.__init__rfrgrhcCrrirrrdrdrern1rzRemoveSmallObjectsd.__call__)rrTFNF)rRr rrrrrrYrrYrrrXrYrZr[ro) rprqrrrsrrtr]rnrurdrdrbrer9 s r9cs6eZdZdZejZ ddfd d ZdddZZS)r<zO Dictionary-based wrapper of :py:class:`monai.transforms.LabelFilter`. FrRr rSequence[int] | intrXrYrZr[cst||t||_dS)a% Args: keys: keys of the corresponding items to be transformed. See also: :py:class:`monai.transforms.compose.MapTransform` applied_labels: Label(s) to filter on. allow_missing_keys: don't raise exception if key is missing. N)r\r]rr_)rarRrrXrbrdrer]?s zLabelFilterd.__init__rfrgrhcCrrirrrdrdrernMrzLabelFilterd.__call__)F)rRr rrrXrYrZr[ro) rprqrrrsrrtr]rnrurdrdrbrer<8s r<cs:eZdZdZejZ   ddfdd ZdddZZS)r0zM Dictionary-based wrapper of :py:class:`monai.transforms.FillHoles`. NFrRr rIterable[int] | int | NonerrrXrYrZr[cs t||t||d|_dS)a Initialize the connectivity and limit the labels for which holes are filled. Args: keys: keys of the corresponding items to be transformed. See also: :py:class:`monai.transforms.compose.MapTransform` applied_labels (Optional[Union[Iterable[int], int]], optional): Labels for which to fill holes. Defaults to None, that is filling holes for all labels. connectivity (int, optional): Maximum number of orthogonal hops to consider a pixel/voxel as a neighbor. Accepted values are ranging from 1 to input.ndim. Defaults to a full connectivity of ``input.ndim``. allow_missing_keys: don't raise exception if key is missing. )rrN)r\r]rr_)rarRrrrXrbrdrer][szFillHolesd.__init__rfrgrhcCrrirrrdrdrernrrzFillHolesd.__call__)NNF) rRr rrrrrXrYrZr[ro) rprqrrrsrrtr]rnrurdrdrbrer0Tsr0cs4eZdZdZejZddfd d ZdddZZS)r?zR Dictionary-based wrapper of :py:class:`monai.transforms.LabelToContour`. LaplaceFrRr kernel_typestrrXrYrZr[cst||t|d|_dS)aJ Args: keys: keys of the corresponding items to be transformed. See also: :py:class:`monai.transforms.compose.MapTransform` kernel_type: the method applied to do edge detection, default is "Laplace". allow_missing_keys: don't raise exception if key is missing. )rN)r\r]rr_)rarRrrXrbrdrer]s zLabelToContourd.__init__rfrgrhcCrrirrrdrdrernrzLabelToContourd.__call__)rF)rRr rrrXrYrZr[ro) rprqrrrsrrtr]rnrurdrdrbrer?ys  r?csJeZdZdZeeejeej@Z  ddfdd Z dddZ Z S)r+z> Base class of dictionary-based ensemble transforms. NFrRr ensembleHCallable[[Sequence[NdarrayOrTensor] | NdarrayOrTensor], NdarrayOrTensor] output_key str | NonerXrYrZr[csrt||t|stdt|jd||_t|jdkr(|dur(t d|dur1||_ dS|jd|_ dS)a Args: keys: keys of the corresponding items to be stack and execute ensemble. if only 1 key provided, suppose it's a PyTorch Tensor with data stacked on dimension `E`. output_key: the key to store ensemble result in the dictionary. ensemble: callable method to execute ensemble on specified data. if only 1 key provided in `keys`, `output_key` can be None and use `keys` as default. allow_missing_keys: don't raise exception if key is missing. Raises: TypeError: When ``ensemble`` is not ``callable``. ValueError: When ``len(keys) > 1`` and ``output_key=None``. Incompatible values. z!ensemble must be callable but is .rNz 1 and output_key=None.r) r\r]callable TypeErrortyperprr^rRr~r)rarRrrrXrbrdrer]s"zEnsembled.__init__rfrgrhcslt|t|jdkr|jdvr|jd}n fdd|D}t|dkr4|||j<S)Nrrcsg|]}|qSrdrd).0rmrlrdre sz&Ensembled.__call__..)rjr^rRrkrr)rarfitemsrdrrerns zEnsembled.__call__)NF) rRr rrrrrXrYrZr[ro) rprqrrrslistsetrrtrr]rnrurdrdrbrer+sr+cs.eZdZdZejZ  d dfd d ZZS)rBzP Dictionary-based wrapper of :py:class:`monai.transforms.MeanEnsemble`. NrRr rrweights(Sequence[float] | NdarrayOrTensor | NonerZr[ct|d}t|||dS)a Args: keys: keys of the corresponding items to be stack and execute ensemble. if only 1 key provided, suppose it's a PyTorch Tensor with data stacked on dimension `E`. output_key: the key to store ensemble result in the dictionary. if only 1 key provided in `keys`, `output_key` can be None and use `keys` as default. weights: can be a list or tuple of numbers for input data with shape: [E, C, H, W[, D]]. or a Numpy ndarray or a PyTorch Tensor data. the `weights` will be added to input data from highest dimension, for example: 1. if the `weights` only has 1 dimension, it will be added to the `E` dimension of input data. 2. if the `weights` has 2 dimensions, it will be added to `E` and `C` dimensions. it's a typical practice to add weights for different classes: to ensemble 3 segmentation model outputs, every output has 4 channels(classes), so the input data shape can be: [3, 4, H, W, D]. and add different `weights` for different classes, so the `weights` shape can be: [3, 4]. for example: `weights = [[1, 2, 3, 4], [4, 3, 2, 1], [1, 1, 1, 1]]`. )rN)rr\r])rarRrrrrbrdrer]s zMeanEnsembled.__init__NN)rRr rrrrrZr[)rprqrrrsrrtr]rurdrdrbrerBs rBcs*eZdZdZejZd dfd d ZZS)rNzP Dictionary-based wrapper of :py:class:`monai.transforms.VoteEnsemble`. NrRr rr num_classesrrZr[cr)aK Args: keys: keys of the corresponding items to be stack and execute ensemble. if only 1 key provided, suppose it's a PyTorch Tensor with data stacked on dimension `E`. output_key: the key to store ensemble result in the dictionary. if only 1 key provided in `keys`, `output_key` can be None and use `keys` as default. num_classes: if the input is single channel data instead of One-Hot, we can't get class number from channel, need to explicitly specify the number of classes to vote. )rN)rr\r])rarRrrrrbrdrer]s zVoteEnsembled.__init__r)rRr rrrrrZr[)rprqrrrsrrtr]rurdrdrbrerNsrNcs>eZdZdZejZ     ddfdd ZdddZZS)rEa- Performs probability based non-maximum suppression (NMS) on the probabilities map via iteratively selecting the coordinate with highest probability and then move it as well as its surrounding values. The remove range is determined by the parameter `box_size`. If multiple coordinates have the same highest probability, only one of them will be selected. Args: spatial_dims: number of spatial dimensions of the input probabilities map. Defaults to 2. sigma: the standard deviation for gaussian filter. It could be a single value, or `spatial_dims` number of values. Defaults to 0.0. prob_threshold: the probability threshold, the function will stop searching if the highest probability is no larger than the threshold. The value should be no less than 0.0. Defaults to 0.5. box_size: the box size (in pixel) to be removed around the pixel with the maximum probability. It can be an integer that defines the size of a square or cube, or a list containing different values for each dimensions. Defaults to 48. Return: a list of selected lists, where inner lists contain probability and coordinates. For example, for 3D input, the inner lists are in the form of [probability, x, y, z]. Raises: ValueError: When ``prob_threshold`` is less than 0.0. ValueError: When ``box_size`` is a list or tuple, and its length is not equal to `spatial_dims`. ValueError: When ``box_size`` has a less than 1 value. ?0FrRr spatial_dimsrsigma?Sequence[float] | float | Sequence[torch.Tensor] | torch.Tensorprob_thresholdfloatbox_sizeint | Sequence[int]rXrYrZr[cs$t||t||||d|_dS)N)rrrr)r\r]rprob_nms)rarRrrrrrXrbrdrer] s  zProbNMSd.__init__rfrgcCrri)rjrkrrrdrdrern.rzProbNMSd.__call__)rrrrF)rRr rrrrrrrrrXrYrZr[)rfrg) rprqrrrsrrtr]rnrurdrdrbrerEsrEc s@eZdZdZdddedddddf d!fdd Zd"dd ZZS)#r3a Utility transform to invert the previously applied transforms. Taking the ``transform`` previously applied on ``orig_keys``, this ``Invertd`` will apply the inverse of it to the data stored at ``keys``. ``Invertd``'s output will also include a copy of the metadata dictionary (originally from ``orig_meta_keys`` or the metadata of ``orig_keys``), with the relevant fields inverted and stored at ``meta_keys``. A typical usage is to apply the inverse of the preprocessing (``transform=preprocessings``) on input ``orig_keys=image`` to the model predictions ``keys=pred``. A detailed usage example is available in the tutorial: https://github.com/Project-MONAI/tutorials/blob/master/3d_segmentation/torch/unet_inference_dict.py Note: - The output of the inverted data and metadata will be stored at ``keys`` and ``meta_keys`` respectively. - To correctly invert the transforms, the information of the previously applied transforms should be available at ``{orig_keys}_transforms``, and the original metadata at ``orig_meta_keys``. (``meta_key_postfix`` is an optional string to conveniently construct "meta_keys" and/or "orig_meta_keys".) see also: :py:class:`monai.transforms.TraceableTransform`. - The transform will not change the content in ``orig_keys`` and ``orig_meta_key``. These keys are only used to represent the data status of ``key`` before inverting. NTFrRr transformr orig_keysKeysCollection | None meta_keysorig_meta_keysmeta_key_postfixrnearest_interpbool | Sequence[bool] to_tensordevice8str | torch.device | Sequence[str | torch.device] | None post_func$Callable | Sequence[Callable] | NonerXrYrZr[c st|| t|tstd||_|durt|t|jn|j|_ |dur/tdt|jnt ||_ t|jt|j krBtdt|t|j|_ t|t|j|_ t|t|j|_t|t|j|_t| t|j|_t| t|j|_t|_dS)aD Args: keys: the key of expected data in the dict, the inverse of ``transforms`` will be applied on it in-place. It also can be a list of keys, will apply the inverse transform respectively. transform: the transform applied to ``orig_key``, its inverse will be applied on ``key``. orig_keys: the key of the original input data in the dict. These keys default to `self.keys` if not set. the transform trace information of ``transforms`` should be stored at ``{orig_keys}_transforms``. It can also be a list of keys, each matches the ``keys``. meta_keys: The key to output the inverted metadata dictionary. The metadata is a dictionary optionally containing: filename, original_shape. It can be a sequence of strings, maps to ``keys``. If None, will try to create a metadata dict with the default key: `{key}_{meta_key_postfix}`. orig_meta_keys: the key of the metadata of original input data. The metadata is a dictionary optionally containing: filename, original_shape. It can be a sequence of strings, maps to the `keys`. If None, will try to create a metadata dict with the default key: `{orig_key}_{meta_key_postfix}`. This metadata dict will also be included in the inverted dict, stored in `meta_keys`. meta_key_postfix: if `orig_meta_keys` is None, use `{orig_key}_{meta_key_postfix}` to fetch the metadata from dict, if `meta_keys` is None, use `{key}_{meta_key_postfix}`. Default: ``"meta_dict"``. nearest_interp: whether to use `nearest` interpolation mode when inverting the spatial transforms, default to `True`. If `False`, use the same interpolation mode as the original transform. It also can be a list of bool, each matches to the `keys` data. to_tensor: whether to convert the inverted data into PyTorch Tensor first, default to `True`. It also can be a list of bool, each matches to the `keys` data. device: if converted to Tensor, move the inverted results to target device before `post_func`, default to None, it also can be a list of string or `torch.device`, each matches to the `keys` data. post_func: post processing for the inverted data, should be a callable function. It also can be a list of callable, each matches to the `keys` data. allow_missing_keys: don't raise exception if key is missing. zAtransform is not invertible, can't invert transform for the data.Nz.meta_keys should have the same length as keys.)r\r]r}rr~rr$r^rRrr#rrrrrrrr _totensor) rarRrrrrrrrrrrXrbrdrer]Rs-  " zInvertd.__init__rfMapping[Hashable, Any]dict[Hashable, Any]c Cst|}|||j|j|j|j|j|j|j|j D],\ }}}}}}} } } t ||t r>||vr=t d|d|dqnt|} | |vrQt d|dq|pY|d|}||vrpt ||t rp||j} ||j}n |t|} ||i}|rt| ddd} ||}t |tjr|}t |t st|dd }t| |_t||_||i}tjr| |t|<||t|<t|j|j|}Wdn1swY||}| rt |t s||}t |t j!r| durt| j"d krt#d | dt |tjr|j$| d }t%| r| |n|||<t||vr0|j|t|<||vrF|p>|d|}||||<q|S) Nztransform info of `z!` is not available in MetaTensor rz5` is not available or no InvertibleTransform applied._nearest) trans_infomode align_cornersT) track_metacpuzEInverted data with type of 'numpy.ndarray' support device='cpu', got )r)&rjrkrrrrrrrrr}rwarningswarnr trace_keyapplied_operationsmetagetr torchTensordetachr"rr USE_META_DICTr!rrinversernpndarrayrr~tor)rarfrlrmorig_keymeta_keyZ orig_meta_keyrrrrr transform_keytransform_info meta_infoinputs input_dictinvertedZ inverted_datardrdrerns             *  zInvertd.__call__)rRr rrrrrrrrrrrrrrrrrrrXrYrZr[)rfrrZr)rprqrrrsDEFAULT_POST_FIXr]rnrurdrdrbrer35s =r3c sFeZdZdZdedddddddf d fdd ZddZddZZS)!rHzW Save the classification results and metadata into CSV file or other storage. Nz./zpredictions.csv,TFrRr rrrrsaverCSVSaver | None output_dirr filename delimiter overwriterYflushrXrZr[c sjt|| t|jdkrtd|pt|||| |d|_| |_t|t|j|_ t|t|j|_ dS)am Args: keys: keys of the corresponding items to model output, this transform only supports 1 key. See also: :py:class:`monai.transforms.compose.MapTransform` meta_keys: explicitly indicate the key of the corresponding metadata dictionary. for example, for data with key `image`, the metadata by default is in `image_meta_dict`. the metadata is a dictionary object which contains: filename, original_shape, etc. it can be a sequence of string, map to the `keys`. if None, will try to construct meta_keys by `key_{meta_key_postfix}`. will extract the filename of input image to save classification results. meta_key_postfix: `key_{postfix}` was used to store the metadata in `LoadImaged`. so need the key to extract the metadata of input image, like filename, etc. default is `meta_dict`. for example, for data with key `image`, the metadata by default is in `image_meta_dict`. the metadata is a dictionary object which contains: filename, original_shape, etc. this arg only works when `meta_keys=None`. if no corresponding metadata, set to `None`. saver: the saver instance to save classification results, if None, create a CSVSaver internally. the saver must provide `save(data, meta_data)` and `finalize()` APIs. output_dir: if `saver=None`, specify the directory to save the CSV file. filename: if `saver=None`, specify the name of the saved CSV file. delimiter: the delimiter character in the saved file, default to "," as the default output type is `csv`. to be consistent with: https://docs.python.org/3/library/csv.html#csv.Dialect.delimiter. overwrite: if `saver=None`, indicate whether to overwriting existing CSV file content, if True, will clear the file before saving. otherwise, will append new content to the CSV file. flush: if `saver=None`, indicate whether to write the cache data to CSV file immediately in this transform and clear the cache. default to True. If False, may need user to call `saver.finalize()` manually or use `ClassificationSaver` handler. allow_missing_keys: don't raise exception if key is missing. rzr@rArCrDrFrGrLrMr,r-rIrJrPrQrdrdrdresf       8  0/?7,%3#6,O8-