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().
• Если это функция, она будет обработана как функция от объектов операции к строкам имён устройств и вызвана каждый раз при создании новой операции. Операция будет назначена устройству с возвращённым именем.
• Если это 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, уникальное имя возвращается без фактического помечания как используемое. Это полезно, когда вызывающий просто хочет узнать, каким будет создаваемое имя.