Cannot create input for nonexistent input layer 'input _ data '

rb210002

Hi, I am creating a custom node for pose classication, for pose detection and landmark I am using the Depthai Blazepose. I have linked my custom node with pose detection and pose landmark node but whenever I tried to run the demo.py file I am encountering error.

RuntimeError: NeuralNetwork(11)- Cannot create input for nonexistent input layer 'input _ data '

Can anyone tell me how to fix this?

Thank you for help in advance!

jakaskerl

Hi rb210002 ,
I'm unable to debug this solely from the picture. Would you mind posting the code as well?
Thanks 🙂

rb210002

Hi jakaskerl , Here is the code that I used for creating the pipeline

 def create_pipeline(self):
        print("Creating pipeline...")
        #Start defining a pipeline
        pipeline = dai.Pipeline()
        pipeline.setOpenVINOVersion(dai.OpenVINO.Version.VERSION_2021_4)
        self.pd_input_length = 224
        self.lm_input_length = 256
        self.pc_input_length = 66

        # ColorCamera
        print("Creating Color Camera...")
        cam = pipeline.create(dai.node.ColorCamera) 
        cam.setResolution(dai.ColorCameraProperties.SensorResolution.THE_1080_P)
        cam.setInterleaved(False)
        cam.setIspScale(self.scale_nd[0], self.scale_nd[1])
        cam.setFps(self.internal_fps)
        cam.setBoardSocket(dai.CameraBoardSocket.RGB)

        if self.crop:
            cam.setVideoSize(self.frame_size, self.frame_size)
            cam.setPreviewSize(self.frame_size, self.frame_size)
        else: 
            cam.setVideoSize(self.img_w, self.img_h)
            cam.setPreviewSize(self.img_w, self.img_h)

        if not self.laconic:
            cam_out = pipeline.create(dai.node.XLinkOut)
            cam_out.setStreamName("cam_out")
            cam_out.input.setQueueSize(1)
            cam_out.input.setBlocking(False)
            cam.video.link(cam_out.input)


        # Define manager script node
        manager_script = pipeline.create(dai.node.Script)
        manager_script.setScript(self.build_manager_script())

        if self.xyz:
            print("Creating MonoCameras, Stereo and SpatialLocationCalculator nodes...")
            # For now, RGB needs fixed focus to properly align with depth.
            # The value used during calibration should be used here
            calib_data = self.device.readCalibration()
            calib_lens_pos = calib_data.getLensPosition(dai.CameraBoardSocket.RGB)
            print(f"RGB calibration lens position: {calib_lens_pos}")
            cam.initialControl.setManualFocus(calib_lens_pos)

            mono_resolution = dai.MonoCameraProperties.SensorResolution.THE_400_P
            left = pipeline.createMonoCamera()
            left.setBoardSocket(dai.CameraBoardSocket.LEFT)
            left.setResolution(mono_resolution)
            left.setFps(self.internal_fps)

            right = pipeline.createMonoCamera()
            right.setBoardSocket(dai.CameraBoardSocket.RIGHT)
            right.setResolution(mono_resolution)
            right.setFps(self.internal_fps)
            
            stereo = pipeline.createStereoDepth()
            stereo.setConfidenceThreshold(230)
            # LR-check is required for depth alignment
            stereo.setLeftRightCheck(True)
            stereo.setDepthAlign(dai.CameraBoardSocket.RGB)
            stereo.setSubpixel(False)  # subpixel True -> latency

            spatial_location_calculator = pipeline.createSpatialLocationCalculator()
            spatial_location_calculator.setWaitForConfigInput(True)
            spatial_location_calculator.inputDepth.setBlocking(False)
            spatial_location_calculator.inputDepth.setQueueSize(1)

            left.out.link(stereo.left)
            right.out.link(stereo.right)    

            stereo.depth.link(spatial_location_calculator.inputDepth)

            manager_script.outputs['spatial_location_config'].link(spatial_location_calculator.inputConfig)
            spatial_location_calculator.out.link(manager_script.inputs['spatial_data'])

        # Define pose detection pre processing (resize preview to (self.pd_input_length, self.pd_input_length))
        print("Creating Pose Detection pre processing image manip...")
        pre_pd_manip = pipeline.create(dai.node.ImageManip)
        pre_pd_manip.setMaxOutputFrameSize(self.pd_input_length*self.pd_input_length*3)
        pre_pd_manip.setWaitForConfigInput(True)
        pre_pd_manip.inputImage.setQueueSize(1)
        pre_pd_manip.inputImage.setBlocking(False)
        cam.preview.link(pre_pd_manip.inputImage)
        # manager_script.outputs['pre_pd_manip_cfg'].link(pre_pd_manip.inputConfig)

        # Define pose classification pre processing
        print("Creating Pose Classification pre processing image manip...")
        pre_pc_manip = pipeline.create(dai.node.ImageManip)
        pre_pc_manip.setMaxOutputFrameSize(self.pc_input_length*self.pc_input_length*3)
        pre_pc_manip.setWaitForConfigInput(True)
        pre_pc_manip.inputImage.setQueueSize(1)
        pre_pc_manip.inputImage.setBlocking(False)
        cam.preview.link(pre_pc_manip.inputImage)
        manager_script.outputs['pre_pd_manip_cfg'].link(pre_pd_manip.inputConfig)
        
        # Define pose detection model
        print("Creating Pose Detection Neural Network...")
        pd_nn = pipeline.create(dai.node.NeuralNetwork)
        pd_nn.setBlobPath(self.pd_model)

        pre_pd_manip.out.link(pd_nn.input)
       
        # Define pose detection post processing "model"
        print("Creating Pose Detection post processing Neural Network...")
        post_pd_nn = pipeline.create(dai.node.NeuralNetwork)
        post_pd_nn.setBlobPath(self.pp_model)
        pd_nn.out.link(post_pd_nn.input)
        post_pd_nn.out.link(manager_script.inputs['from_post_pd_nn'])

        # Define link to send result to host 
        manager_out = pipeline.create(dai.node.XLinkOut)
        manager_out.setStreamName("manager_out")
        manager_script.outputs['host'].link(manager_out.input)

        # Define landmark pre processing image manip
        print("Creating Landmark pre processing image manip...") 
        pre_lm_manip = pipeline.create(dai.node.ImageManip)
        pre_lm_manip.setMaxOutputFrameSize(self.lm_input_length*self.lm_input_length*3)
        pre_lm_manip.setWaitForConfigInput(True)
        pre_lm_manip.inputImage.setQueueSize(1)
        pre_lm_manip.inputImage.setBlocking(False)
        cam.preview.link(pre_lm_manip.inputImage)

        manager_script.outputs['pre_lm_manip_cfg'].link(pre_lm_manip.inputConfig)

        print("Creating DiveideBy255 Neural Network...") 
        divide_nn = pipeline.create(dai.node.NeuralNetwork)
        divide_nn.setBlobPath(self.divide_by_255_model)
        pre_lm_manip.out.link(divide_nn.input) 

        # Define landmark model
        print("Creating Landmark Neural Network...") 
        lm_nn = pipeline.create(dai.node.NeuralNetwork)
        lm_nn.setBlobPath(self.lm_model)
        # lm_nn.setNumInferenceThreads(1)
        divide_nn.out.link(lm_nn.input)       
        lm_nn.out.link(manager_script.inputs['from_lm_nn'])

        # Define Pose Classify model
        print("Creating Pose Classify Neural Network...") 
        pc_nn = pipeline.create(dai.node.NeuralNetwork)
        pc_nn.setBlobPath(self.pc_model)
        lm_nn.out.link(pc_nn.input)
        pc_nn.out.link(manager_script.inputs['from_pc_nn'])

        print(pc_nn.inputs['input_data'])
        print("Pipeline created.")

        return pipeline        `

jakaskerl

Hi rb210002
Running pipeline graph quickly points to the fact pre_pc_manip output is not connected to anything 🙂

Hope this helps,
Jaka

rb210002

HI jakaskerl , I have connected the output of pre_pc_manip to the pc_nn input. However, even after linking the pre_pc_manip, I am getting the same error.

I tried to look at the pipeline graph, but whenever I run the pipeline_graph run "python demo.py" I am getting this error
Inside the demo.py the BlazeposeDepthaiEdge class object is created.

from . NodeGraphQt import NodeGraph, BaseNode, PropertiesBinWidget
ImportError: attempted relative import with no known parent package

sambutle

rb210002 ImportError: attempted relative import with no known parent package

When attempting a relative import in Python, you may encounter an error message that says "attempted relative import with no known parent package." This error message is usually triggered when you are trying to import a module from a package using a relative import, but the package's name is not recognized by Python as a valid package.

To fix this error, you need to make sure that the module being imported is part of a package, and that the package is on the Python path. You can do this by adding an empty init.py file to the package's directory, and by making sure that the directory containing the package is on the Python path.

Also, you can try one or more of the following solutions:

Use an absolute import instead of a relative import.
Ensure that the package's name is spelled correctly and that the package is located in a directory that Python can find.
Make sure that the package's directory contains an init.py file, which is required for Python to recognize the directory as a package.
Check that you are running your Python script or program from the correct directory, which contains the package you are trying to import.
Consider restructuring your project to avoid using relative imports altogether.

rb210002

Hi Team,
Looking for a resolution. Kindly help.

Regards

jakaskerl

Hi rb210002
Sorry for the late reply, maybe for a start, try removing print(pc_nn.inputs['input_data']) and adding the code for the manager_script as well. Also, which neural network is NeuralNetwork(11)?
As far as importError goes, seems like the file tree for pipeline_graph is incorrect; maybe try to reinstall it.

Thanks,
Jaka

rb210002

Hi, @jackassery#p7257, I tried running the file again, but I have not yet added the changes that you asked me to make. Unfortunately, I encountered a new error

IndexError: invalid map<K, T>.

This error was not present in my earlier attempts, where I encountered the error RuntimeError: NeuralNetwork(11) - Cannot create input for nonexistent input.

Additionally, I tried reinstalling the pipeline_graph package to address the issue with the pipeline graph, but the same error persists. Do you have any suggestions for how to resolve these issues?

jakaskerl

Hi rb210002,
I've seen this error once before, where openvino version was incorrect (or not necessarily incorrect, just causing problems). Try switching/forcing openvino version inside your project. Perhaps it could solve the input_data problem as well.

For pipeline graph, maybe try installing this version so you can be sure it overrides previous version.

Hope this helps,
Jaka

rb210002

Hi sambutle , the error ImportError: attempted relative import with no known parent package is fixed,I added the path of the NodeGraphQt and it's working now thanks for your help.

rb210002

Hi @jakaskerl, just wanted to provide an update on the pipeline error. Although I attempted to resolve the issue by changing the OpenVino version, it did not work. However, I was able to fix the problem by completely uninstalling and reinstalling Depthai. As a result, the 'IndexError: invalid map<K, T>' error has been resolved, and the pipeline graph is now being created successfully.

Thanks for your help.

lauryfriese

@Candy Crush If you're uncertain about the names of the layers in your model, you can print or inspect the model's summary or layer names to verify the exact names of the layers. This can help identify any discrepancies between the code and the model.