def deserialize_and_build(self, serialized_pipeline): """Deserialize and build the pipeline given in serialized form. Parameters ---------- serialized_pipeline : str Serialized pipeline. """ self._pipe = b.Pipeline(serialized_pipeline, self._max_batch_size, self._num_threads, self._device_id, self._exec_pipelined, self._prefetch_queue_depth, self._exec_async, self._bytes_per_sample, self._set_affinity, self._max_streams, self._default_cuda_stream_priority) self._pipe.SetExecutionTypes(self._exec_pipelined, self._exec_separated, self._exec_async) self._pipe.SetQueueSizes(self._cpu_queue_size, self._gpu_queue_size) self._pipe.EnableExecutorMemoryStats(self._enable_memory_stats) self._prepared = True self._pipe.Build() self._built = True
def _prepare_graph(self): self._pipe = b.Pipeline( self._batch_size, self._num_threads, self._device_id, self._seed, self._exec_pipelined, self._prefetch_queue_depth, self._exec_async, self._bytes_per_sample, self._set_affinity, self._max_streams, self._default_cuda_stream_priority) self._pipe.SetExecutionTypes(self._exec_pipelined, self._exec_separated, self._exec_async) self._pipe.SetQueueSizes(self._cpu_queue_size, self._gpu_queue_size) outputs = self.define_graph() if (not isinstance(outputs, tuple) and not isinstance(outputs, list)): outputs = (outputs, ) for output in outputs: if not isinstance(output, Edge.EdgeReference): raise TypeError( ("Expected outputs of type " "EdgeReference. Received " "output type {}").format(type(output).__name__)) # Backtrack to construct the graph op_ids = set() edges = deque(outputs) ops = [] while edges: current_edge = edges.popleft() source_op = current_edge.source if source_op is None: raise RuntimeError("Pipeline encountered " "Edge with no source op.") # To make sure we don't double count ops in # the case that they produce more than one # output, we keep track of the unique op ids # for each op we encounter and only add the # op if we have not already if source_op.id not in op_ids: op_ids.add(source_op.id) source_op.check_args() ops.append(source_op) else: # If the op was already added, we need to # change its position to the top of the list. # This ensures topological ordering of ops # when adding to the backend pipeline ops.remove(source_op) ops.append(source_op) for edge in source_op.inputs: if isinstance(edge, list): for e in edge: edges.append(e) else: edges.append(edge) # Add the ops to the graph and build the backend while ops: op = ops.pop() self._pipe.AddOperator(op.spec, op.name) self._prepared = True self._names_and_devices = [(e.name, e.device) for e in outputs]
def deserialize_and_build(self, serialized_pipeline): self._pipe = b.Pipeline(serialized_pipeline, self._batch_size, self._num_threads, self._device_id, self._exec_pipelined, self._exec_async, self._bytes_per_sample, self._set_affinity, self._max_streams) self._prepared = True self._pipe.Build() self._built = True
def deserialize(cls, serialized_pipeline=None, filename=None, **kwargs): """Deserialize and build pipeline. Deserialize pipeline, previously serialized with ``serialize()`` method. Returned pipeline is already built. Alternatively, additional arguments can be passed, which will be used when instantiating the pipeline. Refer to Pipeline constructor for full list of arguments. By default, the pipeline will be instantiated with the arguments from serialized pipeline. Note, that ``serialized_pipeline`` and ``filename`` parameters are mutually exclusive Parameters ---------- serialized_pipeline : str Pipeline, serialized using ``serialize()`` method. filename : str File, from which serialized pipeline will be read. kwargs : dict Refer to Pipeline constructor for full list of arguments. Returns ---------- Deserialized and built pipeline. """ kw = kwargs if (serialized_pipeline is None) == (filename is None): # XNOR raise ValueError( "serialized_pipeline and filename arguments are mutually exclusive. " "Precisely one of them should be defined.") pipeline = cls() if filename is not None: with open(filename, 'rb') as pipeline_file: serialized_pipeline = pipeline_file.read() pipeline._pipe = b.Pipeline(serialized_pipeline, kw.get("batch_size", -1), kw.get("num_threads", -1), kw.get("device_id", -1), kw.get("exec_pipelined", True), kw.get("prefetch_queue_depth", 2), kw.get("exec_async", True), kw.get("bytes_per_sample", 0), kw.get("set_affinity", False), kw.get("max_streams", -1), kw.get("default_cuda_stream_priority", 0)) pipeline._pipe.SetExecutionTypes(pipeline._exec_pipelined, pipeline._exec_separated, pipeline._exec_async) pipeline._pipe.SetQueueSizes(pipeline._cpu_queue_size, pipeline._gpu_queue_size) pipeline._pipe.EnableExecutorMemoryStats(pipeline._enable_memory_stats) pipeline._prepared = True pipeline._pipe.Build() pipeline._built = True return pipeline
def deserialize_and_build(self, serialized_pipeline): """Deserialize and build the pipeline given in serialized form. Parameters ---------- serialized_pipeline : str Serialized pipeline. """ self._pipe = b.Pipeline(serialized_pipeline, self._batch_size, self._num_threads, self._device_id, self._exec_pipelined, self._exec_async, self._bytes_per_sample, self._set_affinity, self._max_streams) self._prepared = True self._pipe.Build() self._built = True
def __init__(self, batch_size, num_threads, device_id, seed=-1, exec_pipelined=True, exec_async=True, bytes_per_sample=0, set_affinity=False, max_streams=-1): self._pipe = b.Pipeline(batch_size, num_threads, device_id, seed, exec_pipelined, exec_async, bytes_per_sample, set_affinity, max_streams) self.seed = seed self._exec_pipelined = exec_pipelined self._built = False self._first_iter = True self._prepared = False self._names_and_devices = None self._exec_async = exec_async self._bytes_per_sample = bytes_per_sample self._set_affinity = set_affinity self._max_streams = max_streams
def _prepare_graph(self, define_graph=None): self._pipe = b.Pipeline( self._batch_size, self._num_threads, self._device_id, self._seed, self._exec_pipelined, self._prefetch_queue_depth, self._exec_async, self._bytes_per_sample, self._set_affinity, self._max_streams, self._default_cuda_stream_priority) self._pipe.SetExecutionTypes(self._exec_pipelined, self._exec_separated, self._exec_async) self._pipe.SetQueueSizes(self._cpu_queue_size, self._gpu_queue_size) if define_graph is not None: if self._graph_out is not None: raise RuntimeError( "Duplicate graph definition - `define_graph` argument " "should not be specified when graph was defined with a call to `set_outputs`." ) else: define_graph = self.define_graph if self._graph_out: outputs = self._graph_out else: with self: outputs = define_graph() if isinstance(outputs, tuple): outputs = list(outputs) elif not isinstance(outputs, list): outputs = [outputs] for i in range(len(outputs)): if isinstance(outputs[i], types.ScalarConstant): import nvidia.dali.ops outputs[i] = nvidia.dali.ops._instantiate_constant_node( "cpu", outputs[i]) _data_node._check(outputs[i]) # Backtrack to construct the graph op_ids = set() edges = deque(list(outputs) + self._sinks) ops = [] while edges: current_edge = edges.popleft() source_op = current_edge.source if source_op is None: raise RuntimeError("Pipeline encountered " "Edge with no source op.") # To make sure we don't double count ops in # the case that they produce more than one # output, we keep track of the unique op ids # for each op we encounter and only add the # op if we have not already if source_op.id not in op_ids: op_ids.add(source_op.id) source_op.check_args() ops.append(source_op) else: # If the op was already added, we need to # change its position to the top of the list. # This ensures topological ordering of ops # when adding to the backend pipeline ops.remove(source_op) ops.append(source_op) for edge in source_op.inputs: if isinstance(edge, list): for e in edge: edges.append(e) else: edges.append(edge) # Add the ops to the graph and build the backend related_logical_id = {} self._ops = [] while ops: op = ops.pop() self._ops.append(op) if op.relation_id not in related_logical_id: related_logical_id[op.relation_id] = self._pipe.AddOperator( op.spec, op.name) else: self._pipe.AddOperator(op.spec, op.name, related_logical_id[op.relation_id]) self._prepared = True self._setup_input_callbacks() self._names_and_devices = [(e.name, e.device) for e in outputs]