mindspore 1.10.0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/dataset/engine/graphdata.py

@@ -38,7 +38,7 @@ from .datasets_user_defined import GeneratorDataset
 
 class SamplingStrategy(IntEnum):
     """
-    Specifies the sampling strategy when execute `get_sampled_neighbors`.
+    Specifies the sampling strategy when execute `get_sampled_neighbors` .
 
     - RANDOM: Random sampling with replacement.
     - EDGE_WEIGHT: Sampling with edge weight as probability.
@@ -55,7 +55,7 @@ DE_C_INTER_SAMPLING_STRATEGY = {
 
 class OutputFormat(IntEnum):
     """
-    Specifies the output storage format when execute `get_all_neighbors`.
+    Specifies the output storage format when execute `get_all_neighbors` .
 
     - NORMAL: Normal format.
     - COO: COO format.
@@ -79,14 +79,14 @@ class GraphData:
     Support reading graph datasets like Cora, Citeseer and PubMed.
 
     About how to load raw graph dataset into MindSpore please
-    refer to `Loading Graph Dataset <https://www.mindspore.cn/tutorials/zh-CN/
-    r1.10/advanced/dataset/augment_graph_data.html>`_.
+    refer to `Loading Graph Dataset <https://www.mindspore.cn/tutorials/en/
+    r2.0/advanced/dataset/augment_graph_data.html>`_ .
 
     Args:
         dataset_file (str): One of file names in the dataset.
-        num_parallel_workers (int, optional): Number of workers to process the dataset in parallel
-            (default=None).
-        working_mode (str, optional): Set working mode, now supports 'local'/'client'/'server' (default='local').
+        num_parallel_workers (int, optional): Number of workers to process the dataset in parallel.
+            Default: None.
+        working_mode (str, optional): Set working mode, now supports 'local'/'client'/'server'. Default: 'local'.
 
             - 'local', used in non-distributed training scenarios.
 
@@ -97,15 +97,15 @@ class GraphData:
               and is available to the client.
 
         hostname (str, optional): Hostname of the graph data server. This parameter is only valid when
-            working_mode is set to 'client' or 'server' (default='127.0.0.1').
+            `working_mode` is set to 'client' or 'server'. Default: '127.0.0.1'.
         port (int, optional): Port of the graph data server. The range is 1024-65535. This parameter is
-            only valid when working_mode is set to 'client' or 'server' (default=50051).
+            only valid when `working_mode` is set to 'client' or 'server'. Default: 50051.
         num_client (int, optional): Maximum number of clients expected to connect to the server. The server will
-            allocate resources according to this parameter. This parameter is only valid when working_mode
-            is set to 'server' (default=1).
-        auto_shutdown (bool, optional): Valid when working_mode is set to 'server',
-            when the number of connected clients reaches num_client and no client is being connected,
-            the server automatically exits (default=True).
+            allocate resources according to this parameter. This parameter is only valid when `working_mode`
+            is set to 'server'. Default: 1.
+        auto_shutdown (bool, optional): Valid when `working_mode` is set to 'server',
+            when the number of connected clients reaches `num_client` and no client is being connected,
+            the server automatically exits. Default: True.
 
     Raises:
         ValueError: If `dataset_file` does not exist or permission denied.
@@ -202,6 +202,13 @@ class GraphData:
         Returns:
             numpy.ndarray, array of nodes.
 
+        Examples:
+            >>> from mindspore.dataset import GraphData
+            >>>
+            >>> g = ds.GraphData("/path/to/testdata", 1)
+            >>> edges = g.get_all_edges(0)
+            >>> nodes = g.get_nodes_from_edges(edges)
+
         Raises:
             TypeError: If `edge_list` is not list or ndarray.
         """
@@ -233,7 +240,7 @@ class GraphData:
     @check_gnn_get_all_neighbors
     def get_all_neighbors(self, node_list, neighbor_type, output_format=OutputFormat.NORMAL):
         """
-        Get `neighbor_type` neighbors of the nodes in `node_list`.
+        Get `neighbor_type` neighbors of the nodes in `node_list` .
         We try to use the following example to illustrate the definition of these formats. 1 represents connected
         between two nodes, and 0 represents not connected.
 
@@ -324,7 +331,7 @@ class GraphData:
         Args:
             node_list (Union[list, numpy.ndarray]): The given list of nodes.
             neighbor_type (int): Specify the type of neighbor node.
-            output_format (OutputFormat, optional): Output storage format (default=OutputFormat.NORMAL)
+            output_format (OutputFormat, optional): Output storage format. Default: OutputFormat.NORMAL.
                 It can be any of [OutputFormat.NORMAL, OutputFormat.COO, OutputFormat.CSR].
 
         Returns:
@@ -365,14 +372,14 @@ class GraphData:
         next-hop sampling. A maximum of 6-hop are allowed.
 
         The sampling result is tiled into a list in the format of [input node, 1-hop sampling result,
-        2-hop sampling result ...]
+        2-hop sampling result ...].
 
         Args:
             node_list (Union[list, numpy.ndarray]): The given list of nodes.
             neighbor_nums (Union[list, numpy.ndarray]): Number of neighbors sampled per hop.
             neighbor_types (Union[list, numpy.ndarray]): Neighbor type sampled per hop, type of each element in
                 neighbor_types should be int.
-            strategy (SamplingStrategy, optional): Sampling strategy (default=SamplingStrategy.RANDOM).
+            strategy (SamplingStrategy, optional): Sampling strategy. Default: SamplingStrategy.RANDOM.
                 It can be any of [SamplingStrategy.RANDOM, SamplingStrategy.EDGE_WEIGHT].
 
                 - SamplingStrategy.RANDOM, random sampling with replacement.
@@ -401,7 +408,7 @@ class GraphData:
     @check_gnn_get_neg_sampled_neighbors
     def get_neg_sampled_neighbors(self, node_list, neg_neighbor_num, neg_neighbor_type):
         """
-        Get `neg_neighbor_type` negative sampled neighbors of the nodes in `node_list`.
+        Get `neg_neighbor_type` negative sampled neighbors of the nodes in `node_list` .
 
         Args:
             node_list (Union[list, numpy.ndarray]): The given list of nodes.
@@ -429,7 +436,7 @@ class GraphData:
     @check_gnn_get_node_feature
     def get_node_feature(self, node_list, feature_types):
         """
-        Get `feature_types` feature of the nodes in `node_list`.
+        Get `feature_types` feature of the nodes in `node_list` .
 
         Args:
             node_list (Union[list, numpy.ndarray]): The given list of nodes.
@@ -458,7 +465,7 @@ class GraphData:
     @check_gnn_get_edge_feature
     def get_edge_feature(self, edge_list, feature_types):
         """
-        Get `feature_types` feature of the edges in `edge_list`.
+        Get `feature_types` feature of the edges in `edge_list` .
 
         Args:
             edge_list (Union[list, numpy.ndarray]): The given list of edges.
@@ -492,6 +499,12 @@ class GraphData:
         Returns:
             dict, meta information of the graph. The key is node_type, edge_type, node_num, edge_num,
             node_feature_type and edge_feature_type.
+
+        Examples:
+        >>> from mindspore.dataset import GraphData
+        >>>
+        >>> g = ds.GraphData("/path/to/testdata", 2)
+        >>> graph_info = g.graph_info()
         """
         if self._working_mode == 'server':
             raise Exception("This method is not supported when working mode is server.")
@@ -505,9 +518,9 @@ class GraphData:
         Args:
             target_nodes (list[int]): Start node list in random walk
             meta_path (list[int]): node type for each walk step
-            step_home_param (float, optional): return hyper parameter in node2vec algorithm (Default = 1.0).
-            step_away_param (float, optional): in out hyper parameter in node2vec algorithm (Default = 1.0).
-            default_node (int, optional): default node if no more neighbors found (Default = -1).
+            step_home_param (float, optional): return hyper parameter in node2vec algorithm. Default: 1.0.
+            step_away_param (float, optional): in out hyper parameter in node2vec algorithm. Default: 1.0.
+            default_node (int, optional): default node if no more neighbors found. Default: -1.
                 A default value of -1 indicates that no node is given.
 
         Returns:
@@ -536,8 +549,8 @@ class Graph(GraphData):
     A graph object for storing Graph structure and feature data, and provide capabilities such as graph sampling.
 
     This class supports init graph With input numpy array data, which represent node, edge and its features.
-    If working mode is `local`, there is no need to specify input arguments like `working_mode`, `hostname`, `port`,
-    `num_client`, `auto_shutdown`.
+    If working mode is `local` , there is no need to specify input arguments like `working_mode` , `hostname` , `port` ,
+    `num_client` , `auto_shutdown` .
 
     Args:
         edges(Union[list, numpy.ndarray]): edges of graph in COO format with shape [2, num_edges].
@@ -554,8 +567,8 @@ class Graph(GraphData):
             type of corresponding node. If not provided, default type for each node is "0".
         edge_type(Union[list, numpy.ndarray], optional): type of edges, each element should be string which represent
             type of corresponding edge. If not provided, default type for each edge is "0".
-        num_parallel_workers (int, optional): Number of workers to process the dataset in parallel (default=None).
-        working_mode (str, optional): Set working mode, now supports 'local'/'client'/'server' (default='local').
+        num_parallel_workers (int, optional): Number of workers to process the dataset in parallel. Default: None.
+        working_mode (str, optional): Set working mode, now supports 'local'/'client'/'server'. Default: 'local'.
 
             - 'local', used in non-distributed training scenarios.
 
@@ -566,15 +579,15 @@ class Graph(GraphData):
               and is available to the client.
 
         hostname (str, optional): Hostname of the graph data server. This parameter is only valid when
-            working_mode is set to 'client' or 'server' (default='127.0.0.1').
+            `working_mode` is set to 'client' or 'server'. Default: '127.0.0.1'.
         port (int, optional): Port of the graph data server. The range is 1024-65535. This parameter is
-            only valid when working_mode is set to 'client' or 'server' (default=50051).
+            only valid when `working_mode` is set to 'client' or 'server'. Default: 50051.
         num_client (int, optional): Maximum number of clients expected to connect to the server. The server will
-            allocate resources according to this parameter. This parameter is only valid when working_mode
-            is set to 'server' (default=1).
-        auto_shutdown (bool, optional): Valid when working_mode is set to 'server',
-            when the number of connected clients reaches num_client and no client is being connected,
-            the server automatically exits (default=True).
+            allocate resources according to this parameter. This parameter is only valid when `working_mode`
+            is set to 'server'. Default: 1.
+        auto_shutdown (bool, optional): Valid when `working_mode` is set to 'server',
+            when the number of connected clients reaches `num_client` and no client is being connected,
+            the server automatically exits. Default: True.
 
     Raises:
         TypeError: If `edges` not list or NumPy array.
@@ -726,7 +739,7 @@ class Graph(GraphData):
     @check_gnn_get_all_neighbors
     def get_all_neighbors(self, node_list, neighbor_type, output_format=OutputFormat.NORMAL):
         """
-        Get `neighbor_type` neighbors of the nodes in `node_list`.
+        Get `neighbor_type` neighbors of the nodes in `node_list` .
         We try to use the following example to illustrate the definition of these formats. 1 represents connected
         between two nodes, and 0 represents not connected.
 
@@ -817,7 +830,7 @@ class Graph(GraphData):
         Args:
             node_list (Union[list, numpy.ndarray]): The given list of nodes.
             neighbor_type (str): Specify the type of neighbor node.
-            output_format (OutputFormat, optional): Output storage format (default=OutputFormat.NORMAL)
+            output_format (OutputFormat, optional): Output storage format. Default: OutputFormat.NORMAL.
                 It can be any of [OutputFormat.NORMAL, OutputFormat.COO, OutputFormat.CSR].
 
         Returns:
@@ -862,14 +875,14 @@ class Graph(GraphData):
         next-hop sampling. A maximum of 6-hop are allowed.
 
         The sampling result is tiled into a list in the format of [input node, 1-hop sampling result,
-        2-hop sampling result ...]
+        2-hop sampling result ...].
 
         Args:
             node_list (Union[list, numpy.ndarray]): The given list of nodes.
             neighbor_nums (Union[list, numpy.ndarray]): Number of neighbors sampled per hop.
             neighbor_types (Union[list, numpy.ndarray]): Neighbor type sampled per hop, type of each element in
                 neighbor_types should be str.
-            strategy (SamplingStrategy, optional): Sampling strategy (default=SamplingStrategy.RANDOM).
+            strategy (SamplingStrategy, optional): Sampling strategy. Default: SamplingStrategy.RANDOM.
                 It can be any of [SamplingStrategy.RANDOM, SamplingStrategy.EDGE_WEIGHT].
 
                 - SamplingStrategy.RANDOM, random sampling with replacement.
@@ -905,7 +918,7 @@ class Graph(GraphData):
     @check_gnn_get_neg_sampled_neighbors
     def get_neg_sampled_neighbors(self, node_list, neg_neighbor_num, neg_neighbor_type):
         """
-        Get `neg_neighbor_type` negative sampled neighbors of the nodes in `node_list`.
+        Get `neg_neighbor_type` negative sampled neighbors of the nodes in `node_list` .
 
         Args:
             node_list (Union[list, numpy.ndarray]): The given list of nodes.
@@ -937,7 +950,7 @@ class Graph(GraphData):
     @check_gnn_get_node_feature
     def get_node_feature(self, node_list, feature_types):
         """
-        Get `feature_types` feature of the nodes in `node_list`.
+        Get `feature_types` feature of the nodes in `node_list` .
 
         Args:
             node_list (Union[list, numpy.ndarray]): The given list of nodes.
@@ -973,7 +986,7 @@ class Graph(GraphData):
     @check_gnn_get_edge_feature
     def get_edge_feature(self, edge_list, feature_types):
         """
-        Get `feature_types` feature of the edges in `edge_list`.
+        Get `feature_types` feature of the edges in `edge_list` .
 
         Args:
             edge_list (Union[list, numpy.ndarray]): The given list of edges.
@@ -1265,11 +1278,11 @@ class InMemoryGraphDataset(GeneratorDataset):
     """
     Basic Dataset for loading graph into memory.
 
-    Recommended to Implement your own dataset with inheriting this class, and implement your own method like `process`,
-    `save` and `load`, refer source code of `ArgoverseDataset` for how to implement your own dataset. When init your own
-    dataset like ArgoverseDataset, The executed process like follows. Check if there are already processed data under
-    given `data_dir`, if so will call `load` method to load it directly, otherwise it will call `process` method to
-    create graphs and call `save` method to save the graphs into `save_dir`.
+    Recommended to Implement your own dataset with inheriting this class, and implement your own method like `process` ,
+    `save` and `load` , refer source code of `ArgoverseDataset` for how to implement your own dataset. When init your
+    own dataset like ArgoverseDataset, The executed process like follows. Check if there are already processed data
+    under given `data_dir` , if so will call `load` method to load it directly, otherwise it will call `process` method
+    to create graphs and call `save` method to save the graphs into `save_dir` .
 
     You can access graph in created dataset using `graphs = my_dataset.graphs` and also you can iterate dataset
     and get data using `my_dataset.create_tuple_iterator()` (in this way you need to implement methods like
@@ -1279,24 +1292,36 @@ class InMemoryGraphDataset(GeneratorDataset):
     Args:
         data_dir (str): directory for loading dataset, here contains origin format data and will be loaded in
             `process` method.
-        save_dir (str): relative directory for saving processed dataset, this directory is under `data_dir`
-            (default="./processed").
+        save_dir (str): relative directory for saving processed dataset, this directory is under `data_dir` .
+            Default: './processed'.
         column_names (Union[str, list[str]], optional): single column name or list of column names of the dataset,
-            num of column name should be equal to num of item in return data when implement method like `__getitem__`,
-            (default="graph").
-        num_samples (int, optional): The number of samples to be included in the dataset (default=None, all samples).
-        num_parallel_workers (int, optional): Number of subprocesses used to fetch the dataset in parallel (default=1).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset. Random accessible input is required.
-            (default=None, expected order behavior shown in the table).
-        num_shards (int, optional): Number of shards that the dataset will be divided into (default=None).
-            Random accessible input is required. When this argument is specified, `num_samples` reflects the max
+            num of column name should be equal to num of item in return data when implement method like `__getitem__` .
+            Default: 'graph'.
+        num_samples (int, optional): The number of samples to be included in the dataset. Default: None, all samples.
+        num_parallel_workers (int, optional): Number of subprocesses used to fetch the dataset in parallel. Default: 1.
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset. This parameter can only be
+            specified when the implemented dataset has a random access attribute ( `__getitem__` ). Default: None.
+        num_shards (int, optional): Number of shards that the dataset will be divided into. Default: None.
+            When this argument is specified, `num_samples` reflects the max
             sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This argument must be specified only
-            when num_shards is also specified. Random accessible input is required.
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This argument must be specified only
+            when `num_shards` is also specified.
         python_multiprocessing (bool, optional): Parallelize Python operations with multiple worker process. This
-            option could be beneficial if the Python operation is computational heavy (default=True).
+            option could be beneficial if the Python operation is computational heavy. Default: True.
         max_rowsize(int, optional): Maximum size of row in MB that is used for shared memory allocation to copy
-            data between processes.  This is only used if python_multiprocessing is set to True (default 6 MB).
+            data between processes. This is only used if python_multiprocessing is set to True. Default: 6 MB.
+
+    Raises:
+        TypeError: If `data_dir` is not of type str.
+        TypeError: If `save_dir` is not of type str.
+        TypeError: If `num_parallel_workers` is not of type int.
+        TypeError: If `shuffle` is not of type bool.
+        TypeError: If `python_multiprocessing` is not of type bool.
+        TypeError: If `perf_mode` is not of type bool.
+        RuntimeError: If `data_dir` is not valid or does not exit.
+        RuntimeError: If `num_shards` is specified but `shard_id` is None.
+        RuntimeError: If `shard_id` is specified but `num_shards` is None.
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
 
     Examples:
         >>> from mindspore.dataset import InMemoryGraphDataset, Graph
@@ -1315,7 +1340,7 @@ class InMemoryGraphDataset(GeneratorDataset):
         ...     def __getitem__(self, index):
         ...         # this method and '__len__' method are required when iterating created dataset
         ...         graph = self.graphs[index]
-        ...         return graph.get_all_edges("0")
+        ...         return graph.get_all_edges('0')
         ...
         ...     def __len__(self):
         ...         return len(self.graphs)
@@ -1385,19 +1410,28 @@ class ArgoverseDataset(InMemoryGraphDataset):
     Args:
         data_dir (str): directory for loading dataset, here contains origin format data and will be loaded in
             `process` method.
-        column_names (Union[str, list[str]], optional): single column name or list of column names of the dataset,
-            num of column name should be equal to num of item in return data when implement method like `__getitem__`,
-            recommend to specify it with
+        column_names (Union[str, list[str]], optional): single column name or list of column names of the dataset.
+            Default: "graph". Num of column name should be equal to num of item in return data when implement method
+            like `__getitem__`, recommend to specify it with
             `column_names=["edge_index", "x", "y", "cluster", "valid_len", "time_step_len"]` like the following example.
-        num_parallel_workers (int, optional): Number of subprocesses used to fetch the dataset in parallel (default=1).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset. Random accessible input is required.
-            (default=None, expected order behavior shown in the table).
+        num_parallel_workers (int, optional): Number of subprocesses used to fetch the dataset in parallel. Default: 1.
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset. This parameter can only be
+            specified when the implemented dataset has a random access attribute ( `__getitem__` ). Default: None.
         python_multiprocessing (bool, optional): Parallelize Python operations with multiple worker process. This
-            option could be beneficial if the Python operation is computational heavy (default=True).
+            option could be beneficial if the Python operation is computational heavy. Default: True.
         perf_mode(bool, optional): mode for obtaining higher performance when iterate created dataset(will call
             `__getitem__` method in this process). Default True, will save all the data in graph
             (like edge index, node feature and graph feature) into graph feature.
 
+    Raises:
+        TypeError: If `data_dir` is not of type str.
+        TypeError: If `num_parallel_workers` is not of type int.
+        TypeError: If `shuffle` is not of type bool.
+        TypeError: If `python_multiprocessing` is not of type bool.
+        TypeError: If `perf_mode` is not of type bool.
+        RuntimeError: If `data_dir` is not valid or does not exit.
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+
     Examples:
         >>> from mindspore.dataset import ArgoverseDataset
         >>>
@@ -1407,6 +1441,37 @@ class ArgoverseDataset(InMemoryGraphDataset):
         ...                                                "time_step_len"])
         >>> for item in graph_dataset.create_dict_iterator(output_numpy=True, num_epochs=1):
         ...     pass
+
+    About Argoverse Dataset:
+
+    Argverse is the first dataset containing high-precision maps, which contains 290KM high-precision map data with
+    geometric shape and semantic information.
+
+    You can unzip the dataset files into the following structure and read by MindSpore's API:
+
+    .. code-block::
+
+        .
+        └── argoverse_dataset_dir
+            ├── train
+            │    ├──...
+            ├── val
+            │    └──...
+            ├── test
+            │    └──...
+
+    Citation:
+
+    .. code-block::
+
+        @inproceedings{Argoverse,
+        author     = {Ming-Fang Chang and John W Lambert and Patsorn Sangkloy and Jagjeet Singh
+                   and Slawomir Bak and Andrew Hartnett and De Wang and Peter Carr
+                   and Simon Lucey and Deva Ramanan and James Hays},
+        title      = {Argoverse: 3D Tracking and Forecasting with Rich Maps},
+        booktitle  = {Conference on Computer Vision and Pattern Recognition (CVPR)},
+        year       = {2019}
+        }
     """
 
     def __init__(self, data_dir, column_names="graph", num_parallel_workers=1, shuffle=None,

mindspore/dataset/engine/iterators.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2022 Huawei Technologies Co., Ltd
+# Copyright 2019-2023 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,9 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Built-in iterators.
-"""
+"""Built-in iterators"""
 from abc import abstractmethod
+from copy import deepcopy
 import json
 import os
 import signal
@@ -22,8 +22,9 @@ import weakref
 import numpy as np
 
 import mindspore._c_dataengine as cde
-from mindspore.common.tensor import Tensor
+from mindspore.common.tensor import Tensor, np_types
 import mindspore.dataset.engine.offload as offload
+from mindspore.dataset.core.config import get_debug_mode
 
 from mindspore import log as logger
 
@@ -75,7 +76,10 @@ class Iterator:
 
         self._runtime_context = cde.PythonRuntimeContext()
         self._runtime_context.Init()
-        consumer = cde.PythonIteratorConsumer(num_epochs)
+        if get_debug_mode():
+            consumer = cde.PythonPullBasedIteratorConsumer(num_epochs)
+        else:
+            consumer = cde.PythonIteratorConsumer(num_epochs)
         consumer.Init(self.ir_tree)
         self._runtime_context.AssignConsumer(consumer)
         self._iterator = self._runtime_context.GetConsumer()
@@ -169,21 +173,58 @@ class Iterator:
             self._col_names = self.__ori_dataset.get_col_names()
         return self._col_names
 
-    def _reset(self, step):
+    def _reset(self, step, epoch):
         """
-        Reset the iterator to the given step number.
+        Reset the iterator to the given step number and epoch number.
 
         Args:
-            step (int): Global step number.
+            step (int): Global step number
+            epoch (int): Global epoch number
         """
-        self._iterator.Reset(step)
+        self._iterator.Reset(step, epoch)
+
+    def __convert_python(self, obj, to_numpy):
+        """
+        Attempts to recursively convert a python object to Numpy array(s) or tensor(s).
+
+        Args:
+            obj (any): the python object to be converted
+            to_numpy (bool): If True, convert primitive types to NumPy array. If False, convert to Tensor.
+                             (return the obj if type isn't supported)
+        """
+        if isinstance(obj, (int, float, bool, str, np.ndarray, np.str_, np.bytes_, *np_types)):
+            # error out if array is of unsupported type
+            if isinstance(obj, np.ndarray) and obj.dtype not in np_types and obj.dtype.kind not in ('U', 'S'):
+                new_line = '\n'
+                raise TypeError("A NumPy array of unsupported type detected: {}."
+                                "\nSupported types are: {}.".format(
+                                    obj.dtype, new_line.join(map(str, (*np_types, np.str_, np.bytes_)))))
+            if to_numpy:
+                return np.array(obj, copy=self._do_copy)
+            if self._do_copy:
+                return Tensor(np.asarray(obj))
+            return Tensor.from_numpy(np.asarray(obj))
+        if isinstance(obj, dict):
+            return {key: self.__convert_python(val, to_numpy) for key, val in obj.items()}
+        if isinstance(obj, tuple):
+            return tuple([self.__convert_python(item, to_numpy) for item in obj])
+        if isinstance(obj, list):
+            return [self.__convert_python(item, to_numpy) for item in obj]
+        # if we can't convert it to Tensor, return the object as is
+        if self._do_copy:
+            return deepcopy(obj)
+        return obj
 
     def _transform_md_to_output(self, t):
         if self._output_numpy:
+            if t.type().is_python():
+                return self.__convert_python(t.as_python(), True)
             return t.as_array()
         return self._transform_md_to_tensor(t)
 
     def _transform_md_to_tensor(self, t):
+        if t.type().is_python():
+            return self.__convert_python(t.as_python(), False)
         array = t.as_array()
         if self._do_copy:
             return Tensor(array)