No module named pydicom while running the MAP

[ArpanGyawali]

I created a Monai Application Package for an skull strip application that takes nifty head CTA scan as input and gives brain segmentation as output. The application works fine and gives the output while running using
monai-deploy exec app/ -i input_file -o Output_Dir -m model.ts

Then i packaged it using
monai-deploy package -b nvcr.io/nvidia/pytorch:22.08-py3 app/ --tag image_name -m model.ts

Now when i run this package using
monai-deploy run packege_image_name input_file Output_Dir

It gives me this error

/opt/conda/lib/python3.8/site-packages/scipy/__init__.py:138: UserWarning: A NumPy version >=1.16.5 and <1.23.0 is required for this version of SciPy (detected version 1.24.4)
  warnings.warn(f"A NumPy version >={np_minversion} and <{np_maxversion} is required for this version of "
Traceback (most recent call last):
  File "/root/.local/lib/python3.8/site-packages/monai/utils/module.py", line 211, in load_submodules
    mod = import_module(name)
  File "/opt/conda/lib/python3.8/importlib/__init__.py", line 127, in import_module
    return _bootstrap._gcd_import(name[level:], package, level)
  File "/root/.local/lib/python3.8/site-packages/monai/deploy/operators/__init__.py", line 39, in <module>
    from .dicom_seg_writer_operator import DICOMSegmentationWriterOperator
  File "/root/.local/lib/python3.8/site-packages/monai/deploy/operators/dicom_seg_writer_operator.py", line 45, in <module>
    class SegmentDescription:
  File "/root/.local/lib/python3.8/site-packages/monai/deploy/operators/dicom_seg_writer_operator.py", line 54, in SegmentDescription
    algorithm_family: Code = codes.DCM.ArtificialIntelligence,
  File "/root/.local/lib/python3.8/site-packages/monai/deploy/utils/importutil.py", line 262, in __getattr__
    raise self._exception
  File "/root/.local/lib/python3.8/site-packages/monai/deploy/utils/importutil.py", line 221, in optional_import
    pkg = __import__(module)  # top level module
monai.deploy.utils.importutil.OptionalImportError: from pydicom.sr.codedict import codes (No module named 'pydicom').

For details about installing the optional dependencies, please visit:
    https://docs.monai.io/en/latest/installation.html#installing-the-recommended-dependencies

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "/opt/conda/lib/python3.8/runpy.py", line 194, in _run_module_as_main
    return _run_code(code, main_globals, None,
  File "/opt/conda/lib/python3.8/runpy.py", line 87, in _run_code
    exec(code, run_globals)
  File "/opt/monai/app/__main__.py", line 1, in <module>
    from app import AISkullStripApp2
  File "/opt/monai/app/app.py", line 3, in <module>
    from SkullStrip_operator import SkullStripOperator
  File "/opt/monai/app/SkullStrip_operator.py", line 6, in <module>
    import monai.deploy.core as md
  File "/root/.local/lib/python3.8/site-packages/monai/__init__.py", line 58, in <module>
    load_submodules(sys.modules[__name__], False, exclude_pattern=excludes)
  File "/root/.local/lib/python3.8/site-packages/monai/utils/module.py", line 221, in load_submodules
    raise type(e)(f"{e}\n{msg}").with_traceback(e.__traceback__) from e  # raise with modified message
  File "/root/.local/lib/python3.8/site-packages/monai/utils/module.py", line 211, in load_submodules
    mod = import_module(name)
  File "/opt/conda/lib/python3.8/importlib/__init__.py", line 127, in import_module
    return _bootstrap._gcd_import(name[level:], package, level)
  File "/root/.local/lib/python3.8/site-packages/monai/deploy/operators/__init__.py", line 39, in <module>
    from .dicom_seg_writer_operator import DICOMSegmentationWriterOperator
  File "/root/.local/lib/python3.8/site-packages/monai/deploy/operators/dicom_seg_writer_operator.py", line 45, in <module>
    class SegmentDescription:
  File "/root/.local/lib/python3.8/site-packages/monai/deploy/operators/dicom_seg_writer_operator.py", line 54, in SegmentDescription
    algorithm_family: Code = codes.DCM.ArtificialIntelligence,
  File "/root/.local/lib/python3.8/site-packages/monai/deploy/utils/importutil.py", line 262, in __getattr__
    raise self._exception
  File "/root/.local/lib/python3.8/site-packages/monai/deploy/utils/importutil.py", line 221, in optional_import
    pkg = __import__(module)  # top level module
monai.deploy.utils.importutil.OptionalImportError: from pydicom.sr.codedict import codes (No module named 'pydicom').

For details about installing the optional dependencies, please visit:
    https://docs.monai.io/en/latest/installation.html#installing-the-recommended-dependencies

Multiple versions of MONAI may have been installed?
Please see the installation guide: https://docs.monai.io/en/stable/installation.html

The code i am using is
SkullStripApp

• app.py
• nifty_data_loader_operator.py
• skull_Strip_operator.py

app.py

import logging

from skull_strip_operator import SkullStripOperator
from pydicom.sr.codedict import codes
from monai.deploy.core.domain import Image
from monai.deploy.core.io_type import IOType

from monai.deploy.core import Application, resource

from nifty_data_loader_operator import NiftiDataLoader
from monai.deploy.operators.monai_bundle_inference_operator import (
    BundleConfigNames,
    IOMapping,
    MonaiBundleInferenceOperator,
)


@resource(cpu=1, gpu=1, memory="7Gi")
class AISkullStripApp(Application):
    def __init__(self, *args, **kwargs):
        """Creates an application instance."""
        self._logger = logging.getLogger(
            "{}.{}".format(__name__, type(self).__name__))
        super().__init__(*args, **kwargs)

    def run(self, *args, **kwargs):
        # This method calls the base class to run. Can be omitted if simply calling through.
        self._logger.info(f"Begin {self.run.__name__}")
        super().run(*args, **kwargs)
        self._logger.info(f"End {self.run.__name__}")

    def compose(self):
        """Creates the app specific operators and chain them up in the processing DAG."""

        self._logger.debug(f"Begin {self.compose.__name__}")

        skull_strip_op = SkullStripOperator()
        nifty_loader_op = NiftiDataLoader()

        self.add_flow(nifty_loader_op, skull_strip_op, {"image": "image"})

        self._logger.debug(f"End {self.compose.__name__}")



if __name__ == "__main__":
    # Creates the app and test it standalone. When running is this mode, please note the following:
    #     -m <model file>, for model file path
    #     -i <DICOM folder>, for input DICOM CT series folder
    #     -o <output folder>, for the output folder, default $PWD/output
    # e.g.
    #     monai-deploy exec app.py -i input -m model/model.ts
    #
    logging.basicConfig(level=logging.DEBUG)
    AISkullStripApp(do_run=True)

skull_strip_operator.py

import logging
from os import path

from numpy import uint8

import monai.deploy.core as md
from monai.deploy.core import ExecutionContext, Image, InputContext, IOType, Operator, OutputContext
from monai.deploy.operators.monai_seg_inference_operator import InMemImageReader, MonaiSegInferenceOperator

from monai.transforms import (
    Activationsd,
    AsDiscreted,
    Compose,
    EnsureChannelFirstd,
    EnsureTyped,
    LoadImaged,
    ScaleIntensityRanged,
    Invertd,
    Spacingd,
    SaveImaged,
    ToTensord,
    KeepLargestConnectedComponentd,
    Flipd,
    Orientationd
)

@md.input("image", Image, IOType.IN_MEMORY)
@md.output("seg_image", Image, IOType.IN_MEMORY)
@md.env(pip_packages=["monai>=0.8.1", "torch>=1.10.2", "numpy>=1.21", "nibabel"])
class SkullStripOperator(Operator):
    """Performs skull striping from a 3d image of Brain CTA"""

    def __init__(self):
        self.logger = logging.getLogger("{}.{}".format(__name__, type(self).__name__))
        super().__init__()
        self._input_dataset_key = "image"
        self._pred_dataset_key = "pred"

    def compute(self, op_input: InputContext, op_output: OutputContext, context: ExecutionContext):

        input_image = op_input.get("image")
        if not input_image:
            raise ValueError("Input image is not found.")

        output_path = context.output.get().path

        # This operator gets an in-memory Image object, so a specialized ImageReader is needed.
        _reader = InMemImageReader(input_image)
        pre_transforms = self.pre_process(_reader)
        post_transforms = self.post_process(pre_transforms, path.join(output_path, "prediction_output"))

        # Delegates inference and saving output to the built-in operator.
        infer_operator = MonaiSegInferenceOperator(
            (
                160,
                160,
                160,
            ),
            pre_transforms,
            post_transforms,
        )

        # Setting the keys used in the dictironary based transforms may change.
        infer_operator.input_dataset_key = self._input_dataset_key
        infer_operator.pred_dataset_key = self._pred_dataset_key

        # Now let the built-in operator handles the work with the I/O spec and execution context.
        infer_operator.compute(op_input, op_output, context)

    def pre_process(self, img_reader) -> Compose:
        """Composes transforms for preprocessing input before predicting on a model."""

        my_key = self._input_dataset_key
        return Compose(
            [
                LoadImaged(keys=my_key, reader=img_reader),
                EnsureTyped(keys=my_key),
                EnsureChannelFirstd(keys=my_key),
                Orientationd(keys=my_key, axcodes="RAS"),
                Spacingd(keys=my_key, pixdim=[1.0, 1.0, 1.0]),
                ScaleIntensityRanged(keys=my_key, a_min=-200, a_max=1000, b_min=0.0, b_max=1.0, clip=True),
            ]
        )

    def post_process(self, pre_transforms: Compose, out_dir: str = "./prediction_output") -> Compose:
        """Composes transforms for postprocessing the prediction results."""

        pred_key = self._pred_dataset_key
        return Compose(
            [
                EnsureTyped(keys=pred_key),
                # Flipd(keys=pred_key, spatial_axis=1),
                #Orientationd(keys=pred_key, axcodes='RPI', labels=(('R', 'L'), ('A', 'P'), ('S', 'I'))),
                #KeepLargestConnectedComponentd(keys=pred_key),
                Invertd(
                    keys=pred_key,
                    transform=pre_transforms,
                    orig_keys=self._input_dataset_key,
                    nearest_interp=False,
                    to_tensor=True,
                ),
                Activationsd(keys=pred_key, softmax=True),
                AsDiscreted(keys=pred_key, argmax=True),

                SaveImaged(
                    keys=pred_key,
                    output_dir=out_dir,
                    output_postfix="seg",
                    output_dtype=uint8,
                ),
            ]
        )

nifty_Data_loader_operator.py

import numpy as np

import monai.deploy.core as md
from monai.deploy.core import DataPath, ExecutionContext, InputContext, IOType, Operator, OutputContext, Image

from monai.utils import MetaKeys, SpaceKeys

from monai.deploy.utils.importutil import optional_import

nib, _ = optional_import("nibabel")


@md.input("image_path", DataPath, IOType.DISK)
@md.output("image", Image, IOType.IN_MEMORY)
@md.env(pip_packages=["SimpleITK>=2.0.2", "nibabel"])
class NiftiDataLoader(Operator):
    """
    This operator reads a nifti image, extracts the numpy array and forwards it to the next operator
    """


    def compute(self, op_input: InputContext, op_output: OutputContext, context: ExecutionContext):
        input_path = op_input.get().path
        image = self.convert_and_save(input_path)
        op_output.set(image)



    def convert_and_save(self, nii_path):
        """
        reads the nifti image and
        """
        img = nib.load(nii_path)
        header = self._get_meta_dict(img)
        header[MetaKeys.AFFINE] = self._get_affine(img)
        data = self._get_array_data(img)
        return Image(data, header)
    
    def _get_meta_dict(self, img) -> dict:
        """
        Get the all the metadata of the image and convert to dict type.

        Args:
            img: a Nibabel image object loaded from an image file.

        """
        # swap to little endian as PyTorch doesn't support big endian
        header2 = dict()
        try:
            header1 = img.header.as_byteswapped("<")
        except ValueError:
            header1 = img.header
        header1 = dict(header1)
        header2["row_pixel_spacing"] = header1["pixdim"][1].item()
        header2["col_pixel_spacing"] = header1["pixdim"][2].item()
        header2["depth_pixel_spacing"] = header1["pixdim"][3].item()
        header1.update(header2)
        return header1
    
    def _get_affine(self, img):
        """
        Get the affine matrix of the image, it can be used to correct
        spacing, orientation or execute spatial transforms.

        Args:
            img: a Nibabel image object loaded from an image file.

        """
        return np.array(img.affine, copy=True)
    
    
    def _get_array_data(self, img):
        """
        Get the raw array data of the image, converted to Numpy array.

        Args:
            img: a Nibabel image object loaded from an image file.

        """
        data = np.asanyarray(img.dataobj, order="C")
        return data.transpose(2, 1, 0)

Can someone please look into the error i am facing? I have the required module pydicom in the environment on which i created the package.

[MMelQin]

@ArpanGyawali Please add pydicom as a package dependency either in the application or one of the operators, e.g. in app.py, add the pip dependency decorator (addition in bold italic)

from monai.deploy.core import Application, resource, env

from nifty_data_loader_operator import NiftiDataLoader
from monai.deploy.operators.monai_bundle_inference_operator import (
BundleConfigNames,
IOMapping,
MonaiBundleInferenceOperator,
)

@resource(cpu=1, gpu=1, memory="7Gi")
@env(pip_packages=["pydicom"])

This is because the pydicom package is not a dependency of the App SDK itself, though one of the operators in monai.deploy.operators module depends on pydicom, making it necessary to denote pydicom as a dependent package any time any operator from monai.deploy.operators is imported in an app. In you case, you are also directly importing codes from pydicom.sr.codedict, so pydicom has to be decorated as a dependency.

[ArpanGyawali]

Thank you so much @MMelQin
This solves this problem.
I have another slight issue.
I have used the script that you provided in this discussion here for running the MAP independent from monai-deploy-sdk. This only works when the input is dicom. It takes the folder containing dicom series as input, but as I have packaged the app that takes nifty file as an input instead of dicom file. How can I modify the run script so that I can pass nifty file as input.
Here, input inside the MAP is /var/monai/input (this contains dicom files as far as i understand), but while loading nifty file, it gives folder doesnt exist error.
Can you help me in this?

[MMelQin]

The folder /var/monai/input in a MAP (container image) is meant to be mapped to the actual file system folder when the MAP is run as a container, e.g. using the -v my_input/folder:/var/monai/input/ option of docker run. The actual folder, my_input/folder, will need to contain the input file(s).