[draft] Enhance python inference API

ONE-DCO-1.0-Signed-off-by: ragmani <ragmani0216@gmail.com>

Author: ragmani

runtime/onert/api/python/package/common/basesession.py

@@ -52,6 +52,32 @@ def _recreate_session(self, backend_session):
             del self.session  # Clean up the existing session
         self.session = backend_session
 
+    def get_inputs_tensorinfo(self) -> list:
+        """
+        Retrieve tensorinfo for all input tensors.
+
+        Returns:
+            list: A list of tensorinfo objects for each input.
+        """
+        num_inputs = self.session.input_size()
+        infos = []
+        for i in range(num_inputs):
+            infos.append(self.session.input_tensorinfo(i))
+        return infos
+
+    def get_outputs_tensorinfo(self) -> list:
+        """
+        Retrieve tensorinfo for all output tensors.
+
+        Returns:
+            list: A list of tensorinfo objects for each output.
+        """
+        num_outputs = self.session.output_size()
+        infos = []
+        for i in range(num_outputs):
+            infos.append(self.session.output_tensorinfo(i))
+        return infos
+
     def set_inputs(self, size, inputs_array=[]):
         """
         Set the input tensors for the session.

runtime/onert/api/python/package/infer/session.py

@@ -6,41 +6,64 @@ class session(BaseSession):
     """
     Class for inference using nnfw_session.
     """
-    def __init__(self, path: str = None, backends: str = "cpu"):
+    def __init__(self, path: str, backends: str = "cpu"):
         """
         Initialize the inference session.
         Args:
             path (str): Path to the model file or nnpackage directory.
             backends (str): Backends to use, default is "cpu".
         """
-        if path is not None:
-            super().__init__(libnnfw_api_pybind.infer.nnfw_session(path, backends))
-            self.session.prepare()
-            self.set_outputs(self.session.output_size())
-        else:
-            super().__init__()
+        super().__init__(libnnfw_api_pybind.infer.nnfw_session(path, backends))
+        self._prepared = False
 
-    def compile(self, path: str, backends: str = "cpu"):
+    def update_inputs_tensorinfo(self, new_infos: list):
         """
-        Prepare the session by recreating it with new parameters.
+        Update all input tensors' tensorinfo at once.
+
         Args:
-            path (str): Path to the model file or nnpackage directory. Defaults to the existing path.
-            backends (str): Backends to use. Defaults to the existing backends.
+            new_infos (list): A list of updated tensorinfo objects for the inputs.
+        Raises:
+            ValueError: If the number of new_infos does not match the session's input size.
         """
-        # Update parameters if provided
-        if path is None:
-            raise ValueError("path must not be None.")
-        # Recreate the session with updated parameters
-        self._recreate_session(libnnfw_api_pybind.infer.nnfw_session(path, backends))
-        # Prepare the new session
-        self.session.prepare()
-        self.set_outputs(self.session.output_size())
-
-    def inference(self):
+        num_inputs = self.session.input_size()
+        if len(new_infos) != num_inputs:
+            raise ValueError(
+                f"Expected {num_inputs} input tensorinfo(s), but got {len(new_infos)}.")
+        for i, info in enumerate(new_infos):
+            self.session.set_input_tensorinfo(i, info)
+
+    def run_inference(self, inputs_array: list) -> list:
         """
-        Perform model and get outputs
+        Run a complete inference cycle:
+         - If the session hhas not been prepared or output buffers have not been set, call prepare() and set_outputs() once.
+         - Automatically configure input buffers based on the provided numpy arrays.
+         - Execute the inference session by calling nnfw_run().
+         - Return the output tensors with proper multi-dimensional shapes.
+
+        This method supports both static and dynamic shape modification:
+         - If update_inputs_tensorinfo() has been called before running inference, the model is compiled
+           with the fixed static input shape.
+         - Otherwise, the input shapes are adjusted dynamically during nnfw_run().
+
+        Args:
+            inputs_array (list): List of numpy arrays representing the input data.
         Returns:
-            list: Outputs from the model.
+            list: A list containing te output numpy arrays.
         """
+        # Check if the session is prepared; if not, call prepare() and set_outputs() once.
+        if not self._prepared:
+            self.session.prepare()
+            self.set_outputs(self.session.output_size())
+            self._prepared = True
+
+        # Verify that the number of provided inputs matches the session's expected input count.
+        if len(inputs_array) != self.session.input_size():
+            raise ValueError(
+                f"Expected {self.session.input_size()} input(s), but received {len(inputs_array)}."
+            )
+        # Configure input buffers using the current session's input size and provided data.
+        self.set_inputs(self.session.input_size(), inputs_array)
+        # Execute the inference.
         self.session.run()
+        # Return the output buffers.
         return self.outputs

runtime/onert/sample/minimal-python/src/minimal.py

@@ -1,4 +1,5 @@
 from onert import infer
+import numpy as np
 import sys
 
 
@@ -8,10 +9,17 @@ def main(nnpackage_path, backends="cpu"):
     session = infer.session(nnpackage_path, backends)
 
     # Prepare input. Here we just allocate dummy input arrays.
-    input_size = session.input_size()
-    session.set_inputs(input_size)
+    input_infos = session.get_inputs_tensorinfo()
+    dummy_inputs = []
+    for info in input_infos:
+        # Retrieve the dimensions list from tensorinfo property.
+        dims = list(info.dims)
+        # Build the shape tuple from tensorinfo dimensions.
+        shape = tuple(dims[:info.rank])
+        # Create a dummy numpy array filled with zeros.
+        dummy_inputs.append(np.zeros(shape, dtype=info.dtype))
 
-    outputs = session.inference()
+    outputs = session.run_inference(dummy_inputs)
 
     print(f"nnpackage {nnpackage_path.split('/')[-1]} runs successfully.")
     return

runtime/onert/sample/minimal-python/src/static_shape_inference.py

@@ -0,0 +1,48 @@
+from onert import infer
+import numpy as np
+import sys
+
+def main(nnpackage_path, backends="cpu"):
+    # Create session and load the nnpackage
+    sess = infer.session(nnpackage_path, backends)
+
+    # Retrieve the current tensorinfo for all inputs.
+    current_input_infos = sess.get_inputs_tensorinfo()
+
+    # Create new tensorinfo objects with a static shape modification.
+    # For this example, assume we change the first dimension (e.g., batch size) to 10.
+    new_input_infos = []
+    for info in current_input_infos:
+        # For example, if the current shape is (?, 4), update it to (10, 4).
+        # We copy the current info and modify the rank and dims.
+        # (Note: Depending on your model, you may want to modify additional dimensions.)
+        new_shape = [10] + list(info.dims[1:info.rank])
+        info.rank = len(new_shape)
+        for i, dim in enumerate(new_shape):
+            info.dims[i] = dim
+        # For any remaining dimensions up to NNFW_MAX_RANK, set them to a default (1).
+        for i in range(len(new_shape), len(info.dims)):
+            info.dims[i] = 1
+        new_input_infos.append(info)
+
+    # Update all input tensorinfos in the session at once.
+    # This will call prepare() and set_outputs() internally.
+    sess.update_inputs_tensorinfo(new_input_infos)
+
+    # Create dummy input arrays based on the new static shapes.
+    dummy_inputs = []
+    for info in new_input_infos:
+        # Build the shape tuple from tensorinfo dimensions.
+        shape = tuple(info.dims[:info.rank])
+        # Create a dummy numpy array filled with zeros.
+        dummy_inputs.append(np.zeros(shape, dtype=info.dtype))
+
+    # Run inference with the new static input shapes.
+    outputs = sess.run_inference(dummy_inputs)
+
+    print(f"Static shape modification sample: nnpackage {nnpackage_path.split('/')[-1]} runs successfully.")
+    return
+
+if __name__ == "__main__":
+    argv = sys.argv[1:]
+    main(*argv)