Esta página foi traduzida pela API Cloud Translation.
Switch to English

tf.Module

TensorFlow 1 versão Ver fonte no GitHub

Base de dados de classe de módulo de rede neural.

Um módulo é denominado um recipiente para tf.Variable s, outros tf.Module s e funções que se aplicam às entradas do utilizador. Por exemplo, uma camada densa em uma rede neural pode ser implementado como um tf.Module :

 class Dense(tf.Module):
   def __init__(self, in_features, out_features, name=None):
     super(Dense, self).__init__(name=name)
     self.w = tf.Variable(
       tf.random.normal([in_features, out_features]), name='w')
     self.b = tf.Variable(tf.zeros([out_features]), name='b')
   def __call__(self, x):
     y = tf.matmul(x, self.w) + self.b
     return tf.nn.relu(y)
  

Você pode usar a camada densa como seria de esperar:

d = Dense(in_features=3, out_features=2)
d(tf.ones([1, 3]))
<tf.Tensor: shape=(1, 2), dtype=float32, numpy=..., dtype=float32)>

Por subclasse tf.Module em vez de object qualquer tf.Variable ou tf.Module casos atribuídos a propriedades de objetos podem ser obtidos utilizando os variables , trainable_variables ou submodules propriedade:

d.variables
    (<tf.Variable 'b:0' shape=(2,) dtype=float32, numpy=...,
    dtype=float32)>,
    <tf.Variable 'w:0' shape=(3, 2) dtype=float32, numpy=..., dtype=float32)>)

Subclasses de tf.Module também pode tirar proveito do _flatten método que pode ser usado para implementar o acompanhamento de quaisquer outros tipos.

Todos os tf.Module classes têm um associado tf.name_scope que pode ser usado para operações de grupo em TensorBoard e criar hierarquias para nomes de variáveis que podem ajudar com a depuração. Sugerimos o uso do escopo nome ao criar aninhados submódulos / parâmetros ou métodos para a frente cujo gráfico que você pode querer inspecionar em TensorBoard. Você pode inserir o escopo nome explicitamente usando with self.name_scope: ou você pode anotar métodos (para além do __init__ ) com @tf.Module.with_name_scope .

 class MLP(tf.Module):
  def __init__(self, input_size, sizes, name=None):
    super(MLP, self).__init__(name=name)
    self.layers = []
    with self.name_scope:
      for size in sizes:
        self.layers.append(Dense(input_size=input_size, output_size=size))
        input_size = size

  @tf.Module.with_name_scope
  def __call__(self, x):
    for layer in self.layers:
      x = layer(x)
    return x
 

name Retorna o nome deste módulo como passou ou determinado no ctor.

name_scope Retorna uma tf.name_scope exemplo para esta classe.
submodules Sequência de todos os sub-módulos.

Sub-módulos são módulos que são propriedades deste módulo, ou encontrado como propriedades de módulos que são propriedades de este módulo (e assim por diante).

a = tf.Module()
b = tf.Module()
c = tf.Module()
a.b = b
b.c = c
list(a.submodules) == [b, c]
True
list(b.submodules) == [c]
True
list(c.submodules) == []
True

trainable_variables Sequência de variáveis ​​treináveis ​​possuído por este módulo e seus submódulos.

variables Sequência de variáveis pertencentes a este módulo e seus submódulos.

Métodos

with_name_scope

Ver fonte

Decorador para entrar automaticamente o escopo nome do módulo.

class MyModule(tf.Module):
  @tf.Module.with_name_scope
  def __call__(self, x):
    if not hasattr(self, 'w'):
      self.w = tf.Variable(tf.random.normal([x.shape[1], 3]))
    return tf.matmul(x, self.w)

Usando o módulo acima deve produzir tf.Variable s e tf.Tensor s cujos nomes incluído o nome do módulo:

mod = MyModule()
mod(tf.ones([1, 2]))
<tf.Tensor: shape=(1, 3), dtype=float32, numpy=..., dtype=float32)>
mod.w
<tf.Variable 'my_module/Variable:0' shape=(2, 3) dtype=float32,
numpy=..., dtype=float32)>

args
method O método para embrulhar.

Devoluções
O método original enrolado de tal modo que ele entra âmbito nome do módulo.