Se usó la API de Cloud Translation para traducir esta página.
Switch to English

tf.Module

TensorFlow 1 versión Ver código fuente en GitHub

Base de clase módulo de red neuronal.

Un módulo es un recipiente llamado para tf.Variable s, otros tf.Module s y funciones que se aplican a la entrada del usuario. Por ejemplo, una capa densa en una red neuronal podría ser implementado como una 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)
  

Puede utilizar la capa densa como era 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 subclases tf.Module en lugar de object cualquier tf.Variable o tf.Module casos asignados a las propiedades del objeto pueden ser recogidos utilizando los variables , trainable_variables o submodules propiedad:

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

Las subclases de tf.Module también pueden tomar ventaja de la _flatten método que puede ser utilizado para implementar el seguimiento de cualquier otro tipo.

Todos tf.Module clases tienen un asociado tf.name_scope que se puede utilizar para agrupar operaciones en TensorBoard y crear jerarquías para los nombres de variables que pueden ayudar con la depuración. Sugerimos usar el ámbito de nombres anidados al crear submódulos / parámetros o métodos forward cuya gráfica que puede ser que desee para inspeccionar en TensorBoard. Puede entrar en el ámbito de nombres utilizando explícitamente with self.name_scope: o puede anotar métodos (aparte de __init__ ) con @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 Devuelve el nombre de este módulo como pasado o determinado en el ctor.

name_scope Devuelve una tf.name_scope instancia de esta clase.
submodules Secuencia de todos los sub-módulos.

Submódulos son módulos que son propiedades de este módulo, o encontrado como propiedades de los módulos que son propiedades de este módulo (y así sucesivamente).

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 Secuencia de variables entrenables propiedad de este módulo y sus submódulos.

variables Secuencia de variables que pertenecen a este módulo y sus submódulos.

Métodos

with_name_scope

Ver fuente

Decorador para ingresar automáticamente el alcance nombre del 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)

Utilizando el módulo anterior produciría tf.Variable s y tf.Tensor s cuyos nombres se incluye el nombre del 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 El método para envolver.

Devoluciones
El método original envuelto de tal manera que entra alcance el nombre del módulo.