fluxo tensor:: Escopo

Um objeto Scope representa um conjunto de operações relacionadas do TensorFlow que têm as mesmas propriedades, como um prefixo de nome comum.

Resumo

Um objeto Scope é um contêiner para propriedades do TensorFlow Op. Os construtores de operações obtêm um objeto Scope como primeiro argumento obrigatório e a operação construída adquire as propriedades do objeto.

Um exemplo simples:

using namespace ops;
Scope root = Scope::NewRootScope();
auto c1 = Const(root, { {1, 1} });
auto m = MatMul(root, c1, { {41}, {1} });
GraphDef gdef;
Status s = root.ToGraphDef(&gdef);
if (!s.ok()) { ... }

Hierarquia de escopo :

A classe Scope fornece várias funções With<> que criam um novo escopo. O novo escopo normalmente tem uma propriedade alterada enquanto outras propriedades são herdadas do escopo pai. O método NewSubScope(name) anexa name ao prefixo dos nomes das operações criadas dentro do escopo e WithOpName() altera o sufixo que, de outra forma, será padronizado para o tipo da operação.

Exemplos de nomes:

Scope root = Scope::NewRootScope();
Scope linear = root.NewSubScope("linear");
// W will be named "linear/W"
auto W = Variable(linear.WithOpName("W"),
                  {2, 2}, DT_FLOAT);
// b will be named "linear/b_3"
int idx = 3;
auto b = Variable(linear.WithOpName("b_", idx),
                  {2}, DT_FLOAT);
auto x = Const(linear, {...});  // name: "linear/Const"
auto m = MatMul(linear, x, W);  // name: "linear/MatMul"
auto r = BiasAdd(linear, m, b); // name: "linear/BiasAdd"

Vida útil do escopo :

Um novo escopo é criado chamando Scope::NewRootScope . Isto cria alguns recursos que são compartilhados por todos os escopos filhos que herdam deste escopo, direta ou transitivamente. Por exemplo, um novo escopo cria um novo objeto Graph ao qual as operações são adicionadas quando o novo escopo ou seus filhos são usados ​​por um construtor Op. O novo escopo também possui um objeto Status que será usado para indicar erros por funções do construtor Op chamadas em qualquer escopo filho. As funções do construtor Op devem verificar o status do escopo chamando o método ok() antes de prosseguir com a construção da operação.

Segurança do fio:

Um objeto Scope NÃO é thread-safe. Threads não podem chamar simultaneamente funções de construtor operacional no mesmo objeto Scope .

Funções públicas

Scope ClearColocation() const 

Scope ColocateWith(
  const Operation & op
) const 

Scope ColocateWith(
  const Output & out
) const 

Scope ExitOnError() const 

CompositeOpScopes GetCompositeOpScopes(
  const string & composite_op_name
) const 

string GetUniqueNameForOp(
  const string & default_name
) const 

Scope NewSubScope(
  const string & child_scope_name
) const 

 Scope(
  const Scope & other
)

Status ToGraphDef(
  GraphDef *gdef
) const 

void UpdateStatus(
  const Status & s
) const 

Scope WithAssignedDevice(
  const string & assigned_device
) const 

Scope WithControlDependencies(
  const gtl::ArraySlice< Operation > & control_deps
) const 

Scope WithControlDependencies(
  const Output & control_dep
) const 

Scope WithDevice(
  const string & device
) const 

Scope WithKernelLabel(
  const string & kernel_label
) const 

Scope WithNoControlDependencies() const 

Scope WithOpName(
  Ty... fragments
) const 

Scope WithXlaCluster(
  const string & xla_cluster
) const 

const std::vector< Operation > & control_deps() const 

Graph * graph() const 

std::shared_ptr< Graph > graph_as_shared_ptr() const 

bool ok() const 

Scope & operator=(
  const Scope & other
)

Status status() const 

 ~Scope()

Scope NewRootScope()