Python tensorflow.python.framework.ops.get_default_graph() Examples
The following are 30
code examples of tensorflow.python.framework.ops.get_default_graph().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
tensorflow.python.framework.ops
, or try the search function
.
Example #1
Source File: variables.py From auto-alt-text-lambda-api with MIT License | 6 votes |
def _init_from_proto(self, variable_def, import_scope=None): """Creates a new variable from `VariableDef` protocol buffer. Args: variable_def: `VariableDef` protocol buffer. import_scope: Optional `string`. Name scope to add. """ assert isinstance(variable_def, variable_pb2.VariableDef) # Create from variable_def. g = ops.get_default_graph() self._variable = g.as_graph_element( ops.prepend_name_scope(variable_def.variable_name, import_scope=import_scope)) self._initializer_op = g.as_graph_element( ops.prepend_name_scope(variable_def.initializer_name, import_scope=import_scope)) self._snapshot = g.as_graph_element( ops.prepend_name_scope(variable_def.snapshot_name, import_scope=import_scope)) if variable_def.HasField("save_slice_info_def"): self._save_slice_info = Variable.SaveSliceInfo( save_slice_info_def=variable_def.save_slice_info_def) else: self._save_slice_info = None self._caching_device = None
Example #2
Source File: utils.py From tensornets with MIT License | 6 votes |
def convert_collection_to_dict(collection, clear_collection=False): """Returns an OrderedDict of Tensors with their aliases as keys. Args: collection: A collection. clear_collection: When True, it clears the collection after converting to OrderedDict. Returns: An OrderedDict of {alias: tensor} """ output = OrderedDict((alias, tensor) for tensor in ops.get_collection(collection) for alias in get_tensor_aliases(tensor)) if clear_collection: ops.get_default_graph().clear_collection(collection) return output
Example #3
Source File: layers.py From tensornets with MIT License | 6 votes |
def _lower_bound(inputs, bound, name=None): """Same as tf.maximum, but with helpful gradient for inputs < bound. The gradient is overwritten so that it is passed through if the input is not hitting the bound. If it is, only gradients that push `inputs` higher than the bound are passed through. No gradients are passed through to the bound. Args: inputs: input tensor bound: lower bound for the input tensor name: name for this op Returns: tf.maximum(inputs, bound) """ with ops.name_scope(name, 'GDNLowerBound', [inputs, bound]) as scope: inputs = ops.convert_to_tensor(inputs, name='inputs') bound = ops.convert_to_tensor(bound, name='bound') with ops.get_default_graph().gradient_override_map( {'Maximum': 'GDNLowerBound'}): return math_ops.maximum(inputs, bound, name=scope)
Example #4
Source File: control_flow_ops.py From lambda-packs with MIT License | 6 votes |
def _init_from_proto(self, context_def, import_scope=None): """Creates a new `CondContext` from protocol buffer. Args: context_def: `CondContextDef` protocol buffer. import_scope: Optional `string`. Name scope to add. """ assert isinstance(context_def, control_flow_pb2.CondContextDef) # Create from context_def. g = ops.get_default_graph() self._name = ops.prepend_name_scope( context_def.context_name, import_scope) self._pred = g.as_graph_element(ops.prepend_name_scope( context_def.pred_name, import_scope)) self._pivot = g.as_graph_element(ops.prepend_name_scope( context_def.pivot_name, import_scope)) self._branch = context_def.branch super(CondContext, self).__init__(values_def=context_def.values_def, import_scope=import_scope)
Example #5
Source File: control_flow_ops.py From lambda-packs with MIT License | 6 votes |
def AddOp(self, op): """Add `op` to the current context.""" # For a reduction op, if op is in a grad context and its input is from # its forward context, moving op to the forward context means we would # store the tensor after the reduction as opposed to the tensor before # reduction, and therefore could significantly reduce memory consumption. # For now, we do this only for a few ops. if op.type in {"Shape", "Size", "Rank"}: grad_ctxt = ops.get_default_graph()._get_control_flow_context() if grad_ctxt: grad_ctxt = grad_ctxt.GetWhileContext() if grad_ctxt.grad_state: op_input_forward_ctxt = _GetWhileContext(op.inputs[0].op) if op_input_forward_ctxt == grad_ctxt.grad_state.forward_context: op_input_ctxt = op.inputs[0].op._get_control_flow_context() op._set_control_flow_context(op_input_ctxt) op_input_ctxt._AddOpInternal(op) return self._AddOpInternal(op)
Example #6
Source File: control_flow_ops.py From lambda-packs with MIT License | 6 votes |
def _FixControlInputsAndContext(self, enters): graph = ops.get_default_graph() # pylint: disable=protected-access for e in enters: if isinstance(e, ops.Tensor): xs = [e] else: if not isinstance(e, (ops.IndexedSlices, sparse_tensor.SparseTensor)): raise TypeError("Type %s not supported" % type(e)) xs = [e.values, e.indices] shape = e.dense_shape if shape is not None: xs.append(shape) for x in xs: inp_op = x.op.inputs[0] control_inputs = graph._control_dependencies_for_inputs([inp_op]) outer_control_inputs = [op for op in control_inputs if self._IsInOuterContext(op)] x.op._set_control_flow_context(self) x.op._add_control_inputs(outer_control_inputs) graph._record_op_seen_by_control_dependencies(x.op) # pylint: enable=protected-access
Example #7
Source File: numerics.py From lambda-packs with MIT License | 6 votes |
def add_check_numerics_ops(): """Connect a `check_numerics` to every floating point tensor. `check_numerics` operations themselves are added for each `half`, `float`, or `double` tensor in the graph. For all ops in the graph, the `check_numerics` op for all of its (`half`, `float`, or `double`) inputs is guaranteed to run before the `check_numerics` op on any of its outputs. Returns: A `group` op depending on all `check_numerics` ops added. """ check_op = [] # This code relies on the ordering of ops in get_operations(). # The producer of a tensor always comes before that tensor's consumer in # this list. This is true because get_operations() returns ops in the order # added, and an op can only be added after its inputs are added. for op in ops.get_default_graph().get_operations(): for output in op.outputs: if output.dtype in [dtypes.float16, dtypes.float32, dtypes.float64]: message = op.name + ":" + str(output.value_index) with ops.control_dependencies(check_op): check_op = [array_ops.check_numerics(output, message=message)] return control_flow_ops.group(*check_op)
Example #8
Source File: evaluation.py From lambda-packs with MIT License | 6 votes |
def _get_or_create_eval_step(): """Gets or creates the eval step `Tensor`. Returns: A `Tensor` representing a counter for the evaluation step. Raises: ValueError: If multiple `Tensors` have been added to the `tf.GraphKeys.EVAL_STEP` collection. """ graph = ops.get_default_graph() eval_steps = graph.get_collection(ops.GraphKeys.EVAL_STEP) if len(eval_steps) == 1: return eval_steps[0] elif len(eval_steps) > 1: raise ValueError('Multiple tensors added to tf.GraphKeys.EVAL_STEP') else: counter = variable_scope.get_variable( 'eval_step', shape=[], dtype=dtypes.int64, initializer=init_ops.zeros_initializer(), trainable=False, collections=[ops.GraphKeys.LOCAL_VARIABLES, ops.GraphKeys.EVAL_STEP]) return counter
Example #9
Source File: basic_session_run_hooks.py From lambda-packs with MIT License | 6 votes |
def before_run(self, run_context): # pylint: disable=unused-argument if self._timer.last_triggered_step() is None: # We do write graph and saver_def at the first call of before_run. # We cannot do this in begin, since we let other hooks to change graph and # add variables in begin. Graph is finalized after all begin calls. training_util.write_graph( ops.get_default_graph().as_graph_def(add_shapes=True), self._checkpoint_dir, "graph.pbtxt") saver_def = self._get_saver().saver_def if self._get_saver() else None graph = ops.get_default_graph() meta_graph_def = meta_graph.create_meta_graph_def( graph_def=graph.as_graph_def(add_shapes=True), saver_def=saver_def) self._summary_writer.add_graph(graph) self._summary_writer.add_meta_graph(meta_graph_def) return SessionRunArgs(self._global_step_tensor)
Example #10
Source File: basic_session_run_hooks.py From lambda-packs with MIT License | 6 votes |
def _as_graph_element(obj): """Retrieves Graph element.""" graph = ops.get_default_graph() if not isinstance(obj, six.string_types): if not hasattr(obj, "graph") or obj.graph != graph: raise ValueError("Passed %s should have graph attribute that is equal " "to current graph %s." % (obj, graph)) return obj if ":" in obj: element = graph.as_graph_element(obj) else: element = graph.as_graph_element(obj + ":0") # Check that there is no :1 (e.g. it's single output). try: graph.as_graph_element(obj + ":1") except (KeyError, ValueError): pass else: raise ValueError("Name %s is ambiguous, " "as this `Operation` has multiple outputs " "(at least 2)." % obj) return element
Example #11
Source File: queue_runner_impl.py From lambda-packs with MIT License | 6 votes |
def _init_from_proto(self, queue_runner_def, import_scope=None): """Create a QueueRunner from `QueueRunnerDef`. Args: queue_runner_def: Optional `QueueRunnerDef` protocol buffer. import_scope: Optional `string`. Name scope to add. """ assert isinstance(queue_runner_def, queue_runner_pb2.QueueRunnerDef) g = ops.get_default_graph() self._queue = g.as_graph_element( ops.prepend_name_scope(queue_runner_def.queue_name, import_scope)) self._enqueue_ops = [g.as_graph_element( ops.prepend_name_scope(op, import_scope)) for op in queue_runner_def.enqueue_op_name] self._close_op = g.as_graph_element(ops.prepend_name_scope( queue_runner_def.close_op_name, import_scope)) self._cancel_op = g.as_graph_element(ops.prepend_name_scope( queue_runner_def.cancel_op_name, import_scope)) self._queue_closed_exception_types = tuple( errors.exception_type_from_error_code(code) for code in queue_runner_def.queue_closed_exception_types) # Legacy support for old QueueRunnerDefs created before this field # was added. if not self._queue_closed_exception_types: self._queue_closed_exception_types = (errors.OutOfRangeError,)
Example #12
Source File: training_util.py From lambda-packs with MIT License | 6 votes |
def create_global_step(graph=None): """Create global step tensor in graph. Args: graph: The graph in which to create the global step tensor. If missing, use default graph. Returns: Global step tensor. Raises: ValueError: if global step tensor is already defined. """ graph = graph or ops.get_default_graph() if get_global_step(graph) is not None: raise ValueError('"global_step" already exists.') # Create in proper graph and base name_scope. with graph.as_default() as g, g.name_scope(None): return variable_scope.get_variable( ops.GraphKeys.GLOBAL_STEP, shape=[], dtype=dtypes.int64, initializer=init_ops.zeros_initializer(), trainable=False, collections=[ops.GraphKeys.GLOBAL_VARIABLES, ops.GraphKeys.GLOBAL_STEP])
Example #13
Source File: base.py From lambda-packs with MIT License | 6 votes |
def _unique_layer_name(name): """Makes a layer name (or arbitrary string) unique within a TensorFlow graph. Arguments: name: String name to make unique. Returns: Unique string name. Example: ``` >>> _unique_layer_name('dense') dense_1 >>> _unique_layer_name('dense') dense_2 ``` """ graph = ops.get_default_graph() layer_name_uids = PER_GRAPH_LAYER_NAME_UIDS[graph] layer_name_uids[name] += 1 return name + '_' + str(layer_name_uids[name])
Example #14
Source File: dataset_ops.py From lambda-packs with MIT License | 6 votes |
def make_one_shot_iterator(self): """Creates an `Iterator` for enumerating the elements of this dataset. **N.B.** The returned iterator will be initialized automatically. A "one-shot" iterator does not currently support re-initialization. Returns: An `Iterator` over the elements of this dataset. """ # NOTE(mrry): We capture by value here to ensure that `_make_dataset()` is # a 0-argument function. @function.Defun(capture_by_value=True) def _make_dataset(): return self.make_dataset_resource() _make_dataset.add_to_graph(ops.get_default_graph()) return Iterator( gen_dataset_ops.one_shot_iterator( dataset_factory=_make_dataset, output_types=nest.flatten(self.output_types), output_shapes=nest.flatten(self.output_shapes)), None, self.output_types, self.output_shapes)
Example #15
Source File: monitors.py From lambda-packs with MIT License | 6 votes |
def _as_graph_element(obj): """Retrieves Graph element.""" graph = ops.get_default_graph() if not isinstance(obj, six.string_types): if not hasattr(obj, "graph") or obj.graph != graph: raise ValueError("Passed %s should have graph attribute that is equal " "to current graph %s." % (obj, graph)) return obj if ":" in obj: element = graph.as_graph_element(obj) else: element = graph.as_graph_element(obj + ":0") # Check that there is no :1 (e.g. it's single output). try: graph.as_graph_element(obj + ":1") except (KeyError, ValueError): pass else: raise ValueError("Name %s is ambiguous, " "as this `Operation` has multiple outputs " "(at least 2)." % obj) return element
Example #16
Source File: ops.py From lambda-packs with MIT License | 6 votes |
def get_name_scope(): """Returns the current name scope of the default graph. For example: ```python with tf.name_scope('scope1'): with tf.name_scope('scope2'): print(tf.contrib.framework.get_name_scope()) ``` would print the string `scope1/scope2`. Returns: A string represnting the current name scope. """ return ops.get_default_graph().get_name_scope()
Example #17
Source File: function.py From lambda-packs with MIT License | 5 votes |
def get_extra_vars(): """Returns the captured variables by the function. Returns: If the default graph is being used to define a function, the returned list of variables are those created inside the function body so far. Otherwise, returns an empty list. """ g = ops.get_default_graph() if isinstance(g, _FuncGraph): return g.extra_vars else: return []
Example #18
Source File: AdaBound.py From HyperGAN with MIT License | 5 votes |
def _create_slots(self, var_list): first_var = min(var_list, key=lambda x: x.name) graph = None if context.executing_eagerly() else ops.get_default_graph() # Create slots for the first and second moments. for v in var_list : self._zeros_slot(v, "m", self._name) self._zeros_slot(v, "v", self._name) self._zeros_slot(v, "vhat", self._name)
Example #19
Source File: random_seed.py From lambda-packs with MIT License | 5 votes |
def get_seed(op_seed): """Returns the local seeds an operation should use given an op-specific seed. Given operation-specific seed, `op_seed`, this helper function returns two seeds derived from graph-level and op-level seeds. Many random operations internally use the two seeds to allow user to change the seed globally for a graph, or for only specific operations. For details on how the graph-level seed interacts with op seeds, see @{tf.set_random_seed}. Args: op_seed: integer. Returns: A tuple of two integers that should be used for the local seed of this operation. """ graph_seed = ops.get_default_graph().seed if graph_seed is not None: if op_seed is None: # pylint: disable=protected-access op_seed = ops.get_default_graph()._last_id seeds = _truncate_seed(graph_seed), _truncate_seed(op_seed) else: if op_seed is not None: seeds = DEFAULT_GRAPH_SEED, _truncate_seed(op_seed) else: seeds = None, None # Avoid (0, 0) as the C++ ops interpret it as nondeterminism, which would # be unexpected since Python docs say nondeterminism is (None, None). if seeds == (0, 0): return (0, _MAXINT32) return seeds
Example #20
Source File: test_util.py From lambda-packs with MIT License | 5 votes |
def setUp(self): self._ClearCachedSession() random.seed(random_seed.DEFAULT_GRAPH_SEED) np.random.seed(random_seed.DEFAULT_GRAPH_SEED) ops.reset_default_graph() ops.get_default_graph().seed = random_seed.DEFAULT_GRAPH_SEED
Example #21
Source File: writer_cache.py From lambda-packs with MIT License | 5 votes |
def get(logdir): """Returns the FileWriter for the specified directory. Args: logdir: str, name of the directory. Returns: A `FileWriter`. """ with FileWriterCache._lock: if logdir not in FileWriterCache._cache: FileWriterCache._cache[logdir] = FileWriter( logdir, graph=ops.get_default_graph()) return FileWriterCache._cache[logdir]
Example #22
Source File: function.py From lambda-packs with MIT License | 5 votes |
def get_extra_inputs(): """Returns the captured input tensors by the function. Returns: If the default graph is being used to define a function, the returned list of tensors are those accessed inside the function body but defined outside the function body so far. Otherwise, returns an empty list. """ g = ops.get_default_graph() if isinstance(g, _FuncGraph): return g.extra_inputs else: return []
Example #23
Source File: meta_graph.py From lambda-packs with MIT License | 5 votes |
def copy_scoped_meta_graph(from_scope, to_scope, from_graph=None, to_graph=None): """Copies a sub-meta_graph from one scope to another. Args: from_scope: `String` name scope containing the subgraph to be copied. to_scope: `String` name scope under which the copied subgraph will reside. from_graph: Optional `Graph` from which to copy the subgraph. If `None`, the default graph is use. to_graph: Optional `Graph` to which to copy the subgraph. If `None`, the default graph is used. Returns: A dictionary of `Variables` that has been copied into `to_scope`. Raises: ValueError: If `from_scope` and `to_scope` are the same while `from_graph` and `to_graph` are also the same. """ from_graph = from_graph or ops.get_default_graph() to_graph = to_graph or ops.get_default_graph() if from_graph == to_graph and from_scope == to_scope: raise ValueError("'from_scope' and 'to_scope' need to be different " "when performing copy in the same graph.") orig_meta_graph, var_list = export_scoped_meta_graph( export_scope=from_scope, graph=from_graph) var_list = import_scoped_meta_graph(orig_meta_graph, graph=to_graph, import_scope=to_scope) return var_list
Example #24
Source File: function.py From lambda-packs with MIT License | 5 votes |
def __call__(self, *args, **kwargs): self.add_to_graph(ops.get_default_graph()) args = [ops.convert_to_tensor(_) for _ in args] + self._extra_inputs ret, op = _call(self._definition.signature, *args, **kwargs) if self._shape_func is not None: shapes = self._shape_func(op) if len(shapes) != len(op.outputs): raise ValueError("shape_func produced %d shapes for %d outputs" % (len(shapes), len(op.outputs))) for (t, shape) in zip(op.outputs, shapes): t.set_shape(shape) return ret
Example #25
Source File: models.py From lambda-packs with MIT License | 5 votes |
def __init__(self, layers=None, name=None): self.layers = [] # Stack of layers. self.model = None # Internal Model instance. self.inputs = [] # List of input tensors self.outputs = [] # List of length 1: the output tensor (unique). self._trainable = True self._initial_weights = None # Model attributes. self.inbound_nodes = [] self.outbound_nodes = [] self.built = False # Set model name. if not name: prefix = 'sequential_' name = prefix + str(K.get_uid(prefix)) self.name = name # The following properties are not actually used by Keras; # they exist for compatibility with TF's variable scoping mechanism. self._updates = [] self._scope = None self._reuse = None self._base_name = name self._graph = ops.get_default_graph() # Add to the model any layers passed to the constructor. if layers: for layer in layers: self.add(layer)
Example #26
Source File: backend.py From lambda-packs with MIT License | 5 votes |
def clear_session(): """Destroys the current TF graph and creates a new one. Useful to avoid clutter from old models / layers. """ global _SESSION global _GRAPH_LEARNING_PHASES # pylint: disable=global-variable-not-assigned ops.reset_default_graph() reset_uids() _SESSION = None phase = array_ops.placeholder(dtype='bool', name='keras_learning_phase') _GRAPH_LEARNING_PHASES = {} _GRAPH_LEARNING_PHASES[ops.get_default_graph()] = phase
Example #27
Source File: backend.py From lambda-packs with MIT License | 5 votes |
def learning_phase(): """Returns the learning phase flag. The learning phase flag is a bool tensor (0 = test, 1 = train) to be passed as input to any Keras function that uses a different behavior at train time and test time. Returns: Learning phase (scalar integer tensor or Python integer). """ graph = ops.get_default_graph() if graph not in _GRAPH_LEARNING_PHASES: phase = array_ops.placeholder(dtype='bool', name='keras_learning_phase') _GRAPH_LEARNING_PHASES[graph] = phase return _GRAPH_LEARNING_PHASES[graph]
Example #28
Source File: backend.py From lambda-packs with MIT License | 5 votes |
def set_learning_phase(value): """Sets the learning phase to a fixed value. Arguments: value: Learning phase value, either 0 or 1 (integers). Raises: ValueError: if `value` is neither `0` nor `1`. """ global _GRAPH_LEARNING_PHASES # pylint: disable=global-variable-not-assigned if value not in {0, 1}: raise ValueError('Expected learning phase to be ' '0 or 1.') _GRAPH_LEARNING_PHASES[ops.get_default_graph()] = value
Example #29
Source File: imperative_graph.py From lambda-packs with MIT License | 5 votes |
def __getattribute__(self, name): """Forwards to the methods in the current graph's `Operation` object.""" op_name = object.__getattribute__(self, '_name') graph = ops.get_default_graph() # Short-circuit getting some of these attributes that are readily # available without forwarding to the actual operation. This is done # because `get_operation_by_name` tries to acquire the parent graph's # lock protecting the nodes_by_* data structures, and these attributes # (not requiring the lock) could be queried by other function holding # the lock. if name == 'name': return op_name elif name == '_as_graph_element': return lambda: self elif name == '__class__': return OperationProxy elif name == 'graph': original_graph = object.__getattribute__(self, '_original_graph') if original_graph.is_child_graph(graph): return graph else: return original_graph else: op = graph.get_operation_by_name(op_name) return getattr(op, name)
Example #30
Source File: function.py From lambda-packs with MIT License | 5 votes |
def get_extra_args(): """Returns the corresponding function arguments for the captured inputs. Returns: If the default graph is being used to define a function, the returned list of place holders are those used inside the function body corresponding those returned by get_extra_inputs(). Otherwise, returns an empty list. """ g = ops.get_default_graph() if isinstance(g, _FuncGraph): return g.extra_args else: return []