Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

tf.Module

TensorFlow 1 Version Quelltext anzeigen auf GitHub

Basis neuronaler Netzwerkmodul-Klasse.

Ein Modul ist ein benannter Behälter für tf.Variable s, andere tf.Module s und Funktionen , die auf eine Benutzereingabe anzuwenden. Zum Beispiel könnte eine dichte Schicht in einem neuronalen Netzwerk als implementiert wird 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)
  

Sie können die dichte Schicht verwenden, wie Sie es erwarten würden:

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

Durch Subklassen tf.Module statt object alle tf.Variable oder tf.Module Instanzen Objekteigenschaften zugeordnet sind, können mit Hilfe der gesammelt werden variables , trainable_variables oder submodules Eigenschaft:

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

Subklassen von tf.Module kann auch die Vorteile der nimmt _flatten Methode , die verwendet werden kann , Verfolgung anderer Typen zu implementieren.

Alle tf.Module Klassen haben eine zugehörige tf.name_scope , die Gruppenoperationen in TensorBoard verwendet werden können , und erstellen Hierarchien für Variablennamen , die mit dem Debuggen helfen können. Wir schlagen vor, mit den Namen Umfang, wenn verschachtelte Submodule / Parameter oder seine Vorwärts-Methoden, deren Graph Sie könnten in TensorBoard untersuchen möchten. Sie können den Namen Umfang explizit mit Eingabe with self.name_scope: oder Sie können Methoden mit Anmerkungen versehen (abgesehen von __init__ ) mit @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 Gibt den Namen dieses Moduls als bestanden oder im Ctor bestimmt.

name_scope Gibt eine tf.name_scope - Instanz für diese Klasse.
submodules Sequenz aller Untermodule.

Submodule sind Module, die Eigenschaften dieses Moduls sind, oder als Eigenschaften von Modulen zu finden, die Eigenschaften dieses Moduls sind (und so weiter).

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 Sequenz von lernenden Variablen im Besitz von diesem Modul und seine Submodule.

variables Reihenfolge der Variablen in diesem Modul und seine Submodule gehört.

Methods

with_name_scope

Quelltext anzeigen

Decorator automatisch den Namen des Moduls Umfang ein.

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)

Das obige Modul erzeugen würde tf.Variable s und tf.Tensor s , deren Namen die Modulnamen enthalten:

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 Das Verfahren zu wickeln.

Kehrt zurück
Die ursprüngliche Methode gewickelt, so dass sie den Anwendungsbereich der Modulnamen eingibt.