tf.Graph

Вычисление TensorFlow, представленное в виде графа потока данных.

tf.Graph()

Графы используются tf.function для представления вычислений функции. Каждый граф содержит набор объектов tf.Operation, представляющих единицы вычисления; и объекты tf.Tensor, представляющие единицы данных, которые передаются между операциями.

Использование графов напрямую (устарело)

Граф tf.Graph может быть построен и использован напрямую без tf.function, как это требовалось в TensorFlow 1, но это устарело, и рекомендуется использовать tf.function вместо этого. Если используется граф напрямую, также необходимы другие устаревшие классы TensorFlow 1 для выполнения графа, такие как tf.compat.v1.Session.

Можно зарегистрировать граф по умолчанию с помощью контекстного менеджера tf.Graph.as_default. Затем операции будут добавлены в граф вместо немедленного выполнения. Например:

g = tf.Graph()
with g.as_default():
  # Define operations and tensors in `g`.
  c = tf.constant(30.0)
  assert c.graph is g

tf.compat.v1.get_default_graph() можно использовать для получения графа по умолчанию.

Важно: этот класс не потокобезопасен для построения графа. Все операции должны создаваться из одного потока или должна быть обеспечена внешняя синхронизация. Если не указано иное, все методы не потокобезопасны.

Экземпляр Graph поддерживает произвольное количество «коллекций», которые идентифицируются по имени. Для удобства при построении большого графа коллекции могут хранить группы связанных объектов: например, tf.Variable использует коллекцию (с именем tf.GraphKeys.GLOBAL_VARIABLES) для всех переменных, созданных во время построения графа. Вызывающая сторона может определить дополнительные коллекции, указав новое имя.

Методы

add_to_collection

Просмотреть исходный код

add_to_collection(
    name, value
)

Хранит value в коллекции с заданным name.

Обратите внимание, что коллекции не являются множествами, поэтому можно несколько раз добавлять значение в коллекцию.

add_to_collections

Просмотреть исходный код

add_to_collections(
    names, value
)

Хранит value в коллекциях, заданных names.

Обратите внимание, что коллекции не являются множествами, поэтому можно несколько раз добавлять значение в коллекцию. Эта функция гарантирует, что дубликаты в names игнорируются, но она не будет проверять предварительное членство value ни в одной из коллекций в names.

names может быть любым итерируемым объектом, но если names является строкой, она обрабатывается как одно имя коллекции.

as_default

Просмотреть исходный код

as_default()

Возвращает контекстный менеджер, который делает этот Graph текущим графом по умолчанию.

Этот метод следует использовать, если вам нужно создать несколько графов в одном процессе. Для удобства предоставляется глобальный граф по умолчанию, и все операции будут добавляться в этот граф, если вы явно не создадите новый граф.

Используйте этот метод с ключевым словом with, чтобы указать, что операции, созданные в рамках блока, должны добавляться в этот граф. В этом случае после выхода из области действия with предыдущий граф по умолчанию снова устанавливается по умолчанию. Существует стек, поэтому можно иметь несколько вложенных уровней вызовов as_default.

Граф по умолчанию является свойством текущего потока. Если вы создаете новый поток и хотите использовать граф по умолчанию в этом потоке, вы должны явно добавить with g.as_default(): в функцию этого потока.

Следующие примеры кода эквивалентны:

# 1. Using Graph.as_default():
g = tf.Graph()
with g.as_default():
  c = tf.constant(5.0)
  assert c.graph is g

# 2. Constructing and making default:
with tf.Graph().as_default() as g:
  c = tf.constant(5.0)
  assert c.graph is g

Если выполнение с жадным режимом включено, операции, созданные в рамках этого контекстного менеджера, будут добавлены в граф вместо немедленного выполнения.

as_graph_def

Просмотреть исходный код

as_graph_def(
    from_version=None, add_shapes=False
)

Возвращает сериализованное представление GraphDef этого графа.

Сериализованное GraphDef может быть импортировано в другой Graph (с использованием tf.import_graph_def) или использоваться с API сеанса C++.

Этот метод потокобезопасен.

as_graph_element

Просмотреть исходный код

as_graph_element(
    obj, allow_tensor=True, allow_operation=True
)

Возвращает объект, на который ссылается obj, как Operation или Tensor.

Эта функция проверяет, что obj представляет элемент этого графа, и выводит информативное сообщение об ошибке, если это не так.

Эта функция является каноническим способом получения/валидации объекта одного из разрешенных типов из внешней ссылки аргумента в API сеанса.

Этот метод может вызываться одновременно из нескольких потоков.

clear_collection

Просмотреть исходный код

clear_collection(
    name
)

Очищает все значения в коллекции.

colocate_with

Просмотреть исходный код

@tf_contextlib.contextmanager
colocate_with(
    op, ignore_existing=False
)

Возвращает контекстный менеджер, который определяет операцию для совместного размещения.

Примечание: эта функция не предназначена для публичного использования, только для внутренних библиотек.

Например:

a = tf.Variable([1.0])
with g.colocate_with(a):
  b = tf.constant(1.0)
  c = tf.add(a, b)

b и c всегда будут совместно размещены с a, независимо от того, где a будет в конечном итоге размещена.

Примечание: Использование области совместного размещения сбрасывает любые существующие ограничения устройства.

Если op равно None, то ignore_existing должно быть True, и новая область сбрасывает все ограничения совместного размещения и устройства.

container

Просмотреть исходный код

@tf_contextlib.contextmanager
container(
    container_name
)

Возвращает контекстный менеджер, который определяет используемый контейнер ресурсов.

Состоятельные операции, такие как переменные и очереди, могут сохранять свои состояния на устройствах, чтобы они могли быть совместно использованы несколькими процессами. Контейнер ресурсов — это строковое имя, под которым отслеживаются эти состоятельные операции. Эти ресурсы могут быть освобождены или очищены с помощью tf.Session.reset().

Например:

with g.container('experiment0'):
  # All stateful Operations constructed in this context will be placed
  # in resource container "experiment0".
  v1 = tf.Variable([1.0])
  v2 = tf.Variable([2.0])
  with g.container("experiment1"):
    # All stateful Operations constructed in this context will be
    # placed in resource container "experiment1".
    v3 = tf.Variable([3.0])
    q1 = tf.queue.FIFOQueue(10, tf.float32)
  # All stateful Operations constructed in this context will be
  # be created in the "experiment0".
  v4 = tf.Variable([4.0])
  q1 = tf.queue.FIFOQueue(20, tf.float32)
  with g.container(""):
    # All stateful Operations constructed in this context will be
    # be placed in the default resource container.
    v5 = tf.Variable([5.0])
    q3 = tf.queue.FIFOQueue(30, tf.float32)

# Resets container "experiment0", after which the state of v1, v2, v4, q1
# will become undefined (such as uninitialized).
tf.Session.reset(target, ["experiment0"])

control_dependencies

Просмотреть исходный код

control_dependencies(
    control_inputs
)

Возвращает контекстный менеджер, который определяет зависимости управления.

Используйте с ключевым словом with, чтобы указать, что все операции, созданные в контексте, должны иметь зависимости управления от control_inputs. Например:

with g.control_dependencies([a, b, c]):
  # `d` and `e` will only run after `a`, `b`, and `c` have executed.
  d = ...
  e = ...

Несколько вызовов control_dependencies() могут быть вложены, и в этом случае новый Operation будет иметь зависимости управления от объединения control_inputs из всех активных контекстов.

with g.control_dependencies([a, b]):
  # Ops constructed here run after `a` and `b`.
  with g.control_dependencies([c, d]):
    # Ops constructed here run after `a`, `b`, `c`, and `d`.

Вы можете передать None, чтобы очистить зависимости управления:

with g.control_dependencies([a, b]):
  # Ops constructed here run after `a` and `b`.
  with g.control_dependencies(None):
    # Ops constructed here run normally, not waiting for either `a` or `b`.
    with g.control_dependencies([c, d]):
      # Ops constructed here run after `c` and `d`, also not waiting
      # for either `a` or `b`.

Примечание: Контекст зависимостей управления применяется только к операциям, созданным в контексте. Простое использование операции или тензора в контексте не добавляет зависимость управления. Следующий пример иллюстрирует этот момент:

# WRONG
def my_func(pred, tensor):
  t = tf.matmul(tensor, tensor)
  with tf.control_dependencies([pred]):
    # The matmul op is created outside the context, so no control
    # dependency will be added.
    return t

# RIGHT
def my_func(pred, tensor):
  with tf.control_dependencies([pred]):
    # The matmul op is created in the context, so a control dependency
    # will be added.
    return tf.matmul(tensor, tensor)

Обратите также внимание, что хотя выполнение операций, созданных в этой области, вызовет выполнение зависимостей, операции, созданные в этой области, могут быть удалены из обычной графы TensorFlow. Например, в следующем фрагменте кода зависимости никогда не выполняются:

loss = model.loss()
with tf.control_dependencies(dependencies):
  loss = loss + tf.constant(1)  # note: dependencies ignored in the
                                # backward pass
return tf.gradients(loss, model.variables)

Это происходит потому, что для вычисления графика градиента нет необходимости вычислять операцию constant(1), созданную на прямой передаче.

create_op

Просмотреть исходный код

create_op(
    op_type, inputs, dtypes=None, input_types=None, name=None, attrs=None,
    op_def=None, compute_shapes=True, compute_device=True
)

Создает операцию в этой графе. (аргументы устарели)

Это интерфейс низкого уровня для создания операции. Большинство программ не будут вызывать этот метод напрямую, а вместо этого будут использовать конструкторы Python для операций, такие как tf.constant(), которые добавляют операции в стандартную графу.

device

Просмотреть исходный код

@tf_contextlib.contextmanager
device(
    device_name_or_function
)

Возвращает контекстный менеджер, который определяет используемое по умолчанию устройство.

Аргумент device_name_or_function может быть именем устройства в строке, функцией устройства или None:

• Если это имя устройства в строке, все операции, созданные в этом контексте, будут назначены устройству с этим именем, если не переопределены вложенным контекстом device().
• Если это функция, она будет обрабатываться как функция от объектов Operation до имен устройств в строках и вызываться каждый раз при создании новой операции. Операция будет назначена устройству с возвращенным именем.
• Если это None, все вызовы device() из окружающего контекста будут проигнорированы.

Дополнительную информацию о допустимом синтаксисе имен устройств см. в документации в DeviceNameUtils.

Например:

with g.device('/device:GPU:0'):
  # All operations constructed in this context will be placed
  # on GPU 0.
  with g.device(None):
    # All operations constructed in this context will have no
    # assigned device.

# Defines a function from `Operation` to device string.
def matmul_on_gpu(n):
  if n.type == "MatMul":
    return "/device:GPU:0"
  else:
    return "/cpu:0"

with g.device(matmul_on_gpu):
  # All operations of type "MatMul" constructed in this context
  # will be placed on GPU 0; all other operations will be placed
  # on CPU 0.

Примечание: Область устройства может быть переопределена оболочками операций или другим кодом библиотеки. Например, операция присваивания переменной v.assign() должна быть совместно размещена с tf.Variable v, и несовместимые области устройств будут проигнорированы.

finalize

Просмотреть исходный код

finalize()

Завершает эту граф, сделав её только для чтения.

После вызова g.finalize(), новые операции не могут быть добавлены в g. Этот метод используется для обеспечения того, чтобы операции не добавлялись в граф, когда он совместно используется между несколькими потоками, например, при использовании tf.compat.v1.train.QueueRunner.

get_all_collection_keys

Просмотреть исходный код

get_all_collection_keys()

Возвращает список коллекций, используемых в этой графе.

get_collection

Просмотреть исходный код

get_collection(
    name, scope=None
)

Возвращает список значений в коллекции с данным name.

Это отличается от get_collection_ref(), которое всегда возвращает фактический список коллекции, если он существует, так как возвращает новый список каждый раз, когда он вызывается.

get_collection_ref

Просмотреть исходный код

get_collection_ref(
    name
)

Возвращает список значений в коллекции с заданным name.

Если коллекция существует, она возвращает сам список, который можно изменить на месте, чтобы изменить коллекцию. Если коллекция не существует, она создаётся как пустой список, и список возвращается.

Это отличается от get_collection(), которое всегда возвращает копию списка коллекции, если она существует, и никогда не создаёт пустую коллекцию.

get_name_scope

Просмотреть исходный код

get_name_scope()

Возвращает текущую область имён.

Например:

with tf.name_scope('scope1'):
  with tf.name_scope('scope2'):
    print(tf.compat.v1.get_default_graph().get_name_scope())

выведет строку scope1/scope2.

get_operation_by_name

Просмотреть исходный код

get_operation_by_name(
    name
)

Возвращает операцию с данным именем.

Этот метод может быть вызван одновременно из нескольких потоков.

get_operations

Просмотреть исходный код

get_operations()

Возвращает список операций в графе.

Вы можете изменять операции на месте, но изменения в списке, такие как вставки/удаления, не влияют на список операций, известных графу.

Этот метод может быть вызван одновременно из нескольких потоков.

get_tensor_by_name

Просмотреть исходный код

get_tensor_by_name(
    name
)

Возвращает тензор с данным именем.

Этот метод может быть вызван одновременно из нескольких потоков.

gradient_override_map

Просмотреть исходный код

@tf_contextlib.contextmanager
gradient_override_map(
    op_type_map
)

ЭКСПЕРИМЕНТАЛЬНО: Менеджер контекста для переопределения функций градиента.

Этот менеджер контекста может быть использован для переопределения функции градиента, которая будет использоваться для операций в рамках области контекста.

Например:

@tf.RegisterGradient("CustomSquare")
def _custom_square_grad(op, grad):
  # ...

with tf.Graph().as_default() as g:
  c = tf.constant(5.0)
  s_1 = tf.square(c)  # Uses the default gradient for tf.square.
  with g.gradient_override_map({"Square": "CustomSquare"}):
    s_2 = tf.square(s_2)  # Uses _custom_square_grad to compute the
                          # gradient of s_2.

is_feedable

Просмотреть исходный код

is_feedable(
    tensor
)

Возвращает True, если и только если tensor является подаваемым.

is_fetchable

Просмотреть исходный код

is_fetchable(
    tensor_or_op
)

Возвращает True, если и только если tensor_or_op доступен для извлечения.

name_scope

Просмотреть исходный код

@tf_contextlib.contextmanager
name_scope(
    name
)

Возвращает менеджер контекста, создающий иерархические имена для операций.

Граф поддерживает стек областей имён. Оператор with name_scope(...): добавляет новое имя в стек на время существования контекста.

Аргумент name будет интерпретироваться следующим образом:

• Строка (не заканчивающаяся на '/') создаст новую область имён, в которой name будет добавлен к префиксу всех операций, созданных в контексте. Если name был использован ранее, он будет сделан уникальным, вызвав self.unique_name(name).
• Область, ранее захваченная оператором with g.name_scope(...) as scope:, будет обрабатываться как "абсолютная" область имён, что позволяет повторно войти в существующие области.
• Значение None или пустая строка сбросят текущую область имён до основной (пустой) области имён.

Например:

with tf.Graph().as_default() as g:
  c = tf.constant(5.0, name="c")
  assert c.op.name == "c"
  c_1 = tf.constant(6.0, name="c")
  assert c_1.op.name == "c_1"

  # Creates a scope called "nested"
  with g.name_scope("nested") as scope:
    nested_c = tf.constant(10.0, name="c")
    assert nested_c.op.name == "nested/c"

    # Creates a nested scope called "inner".
    with g.name_scope("inner"):
      nested_inner_c = tf.constant(20.0, name="c")
      assert nested_inner_c.op.name == "nested/inner/c"

    # Create a nested scope called "inner_1".
    with g.name_scope("inner"):
      nested_inner_1_c = tf.constant(30.0, name="c")
      assert nested_inner_1_c.op.name == "nested/inner_1/c"

      # Treats `scope` as an absolute name scope, and
      # switches to the "nested/" scope.
      with g.name_scope(scope):
        nested_d = tf.constant(40.0, name="d")
        assert nested_d.op.name == "nested/d"

        with g.name_scope(""):
          e = tf.constant(50.0, name="e")
          assert e.op.name == "e"

Само имя области можно получить с помощью with g.name_scope(...) as scope:, которое сохраняет имя области в переменной scope. Это значение может быть использовано для именования операции, которая представляет собой общий результат выполнения операций в области. Например:

inputs = tf.constant(...)
with g.name_scope('my_layer') as scope:
  weights = tf.Variable(..., name="weights")
  biases = tf.Variable(..., name="biases")
  affine = tf.matmul(inputs, weights) + biases
  output = tf.nn.relu(affine, name=scope)

Примечание: Этот конструктор проверяет предоставленное name. Действительные имена областей соответствуют одному из следующих регулярных выражений:

[A-Za-z0-9.][A-Za-z0-9_.\-/]* (for scopes at the root)
[A-Za-z0-9_.\-/]* (for other scopes)

prevent_feeding

Просмотреть исходный код

prevent_feeding(
    tensor
)

Помечает данную tensor как недопустимую для использования в данном графе.

prevent_fetching

Просмотреть исходный код

prevent_fetching(
    op
)

Помечает данную op как недопустимую для извлечения в данном графе.

switch_to_thread_local

Просмотреть исходный код

switch_to_thread_local()

Делает стеки устройства, совмещения и зависимостей локальными для потоков.

Стек устройства, совмещения и зависимостей по умолчанию не являются локальными для потоков. Если к ним обращаются несколько потоков, состояние будет общим. Это означает, что один поток может повлиять на поведение другого потока.

После вызова этого метода стеки становятся локальными для потоков. Если к ним обращаются несколько потоков, состояние не будет общим. Каждый поток использует своё собственное значение; поток не влияет на другие потоки, изменяя такой стек.

Начальное значение для стека каждого потока устанавливается в текущее значение стека при первом вызове switch_to_thread_local().

unique_name

Просмотреть исходный код

unique_name(
    name, mark_as_used=True
)

Возвращает уникальное имя операции для name.

Примечание: Вам редко нужно вызывать unique_name() напрямую. В большинстве случаев вам просто нужно создать блоки with g.name_scope() для генерации структурированных имён.

unique_name используется для генерации структурированных имён, разделенных "/", чтобы помочь идентифицировать операции при отладке графа. Имена операций отображаются в сообщениях об ошибках, сообщённых исполнителем TensorFlow, и в различных инструментах визуализации, таких как TensorBoard.

Если mark_as_used установлено на True, что является значением по умолчанию, создаётся и помечается как используемое новое уникальное имя. Если оно установлено на False, уникальное имя возвращается без фактического помечания как используемого. Это полезно, когда вызывающий просто хочет узнать, каким будет созданное имя.