tensorflow :: Alcance

Un objeto Scope representa un conjunto de operaciones de TensorFlow relacionadas que tienen las mismas propiedades, como un prefijo de nombre común.

Resumen

Un objeto Scope es un contenedor de propiedades de TensorFlow Op. Los constructores de operaciones obtienen un objeto Scope como primer argumento obligatorio y la operación construida adquiere las propiedades del objeto.

Un ejemplo simple:

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()) { ... }

Jerarquía de alcance :

La clase Scope proporciona varias funciones With <> que crean un nuevo ámbito. El nuevo ámbito normalmente tiene una propiedad cambiada mientras que otras propiedades se heredan del ámbito principal. El método NewSubScope (name) agrega el name al prefijo de los nombres de las operaciones creadas dentro del alcance, y WithOpName () cambia el sufijo que, de lo contrario, es el tipo de operación predeterminado.

Ejemplos de nombres:

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 del alcance :

Se crea un nuevo ámbito llamando a Scope :: NewRootScope . Esto crea algunos recursos que son compartidos por todos los ámbitos secundarios que heredan de este ámbito, de forma directa o transitiva. Por ejemplo, un nuevo alcance crea un nuevo objeto Graph al que se agregan operaciones cuando un constructor Op usa el nuevo alcance o sus hijos. El nuevo alcance también tiene un objeto de estado que se usará para indicar errores por las funciones del constructor de operaciones llamadas en cualquier alcance secundario. Las funciones del constructor de operaciones tienen que verificar el estado del alcance llamando al método ok () antes de proceder a construir la operación.

Seguridad del hilo:

Un objeto Scope NO es seguro para subprocesos. Los subprocesos no pueden llamar simultáneamente a funciones op-constructor en el mismo objeto Scope .

Funciones publicas

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