tf.Graph

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

tf.Graph() -> None

Используется в ноутбуках

Графы используются 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) для всех переменных, которые создаются во время построения графа. Вызывающая сторона может определить дополнительные коллекции, указав новое имя.

Методы

Dismantle

Dismantle()

(self: handle) -> None

add_to_collection

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

add_to_collection(
    name, value
) -> None

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

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

add_to_collections

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

add_to_collections(
    names, value
) -> None

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

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

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

as_default

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

as_default() -> ContextManager['Graph']

Возвращает менеджер контекста, который делает этот 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, use_pybind11_proto=False
) -> tf.compat.v1.GraphDef

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

Сериализованное представление можно импортировать в другую графу (используя соответствующий метод) или использовать с API сессии C++.

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

as_graph_element

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

as_graph_element(
    obj, allow_tensor=True, allow_operation=True
) -> Union[tensor_lib.Tensor, 'Operation']

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

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

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

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

clear_collection

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

clear_collection(
    name
) -> None

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

colocate_with

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

@tf_contextlib.contextmanager
colocate_with(
    op, ignore_existing=False
) -> Iterator[None]

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

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

For example:

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
) -> Iterator[str]

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

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

For example:

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
) -> _ControlDependenciesController

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

Используйте с ключевым словом 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)

Это связано с тем, что для вычисления градиента не требуется вычисление операции константы(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
) -> 'Operation'

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

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

device

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

@tf_contextlib.contextmanager
device(
    device_name_or_function
) -> Iterator[None]

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

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

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

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

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

get

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

get() -> GraphType

get_all_collection_keys

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

get_all_collection_keys() -> list[str]

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

get_collection

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

get_collection(
    name, scope=None
) -> list[Any]

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

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

get_collection_ref

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

get_collection_ref(
    name
) -> list[Any]

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

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

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

get_name_scope

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

get_name_scope() -> str

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

Например:

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
) -> 'Operation'

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

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

get_operations

get_operations()

(self: handle) -> список

get_tensor_by_name

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

get_tensor_by_name(
    name
) -> tf.Tensor

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

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

gradient_override_map

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

@tf_contextlib.contextmanager
gradient_override_map(
    op_type_map
) -> Iterator[None]

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

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

Например:

@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
) -> bool

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

is_fetchable

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

is_fetchable(
    tensor_or_op
) -> bool

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

name_scope

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

@tf_contextlib.contextmanager
name_scope(
    name
) -> Iterator[str]

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

Граф поддерживает стек имен пространств. Оператор 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)

new_operations

new_operations()

(self: handle) -> Список[TF_Operation]

num_operations

num_operations()

(self: handle) -> int

op_def_for_type

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

op_def_for_type(
    type
) -> op_def_pb2.OpDef

Возвращает прото OpDef для type. type является строкой.

prevent_feeding

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

prevent_feeding(
    tensor
) -> None

Помечает заданный tensor как неподаваемый в этом графе.

prevent_fetching

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

prevent_fetching(
    op
) -> None

Помечает заданный op как неизвлекаемый в этом графе.

switch_to_thread_local

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

switch_to_thread_local() -> None

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

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

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

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

unique_name

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

unique_name(
    name, mark_as_used=True
) -> str

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

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

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

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

__enter__

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

__enter__() -> GraphType

__exit__

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

__exit__(
    *args
) -> None