Cette page a été traduite par l'API Cloud Translation.
Switch to English

tf.Module

plus par

Tensorflow 1 Version Voir la source sur GitHub

Base de classe de module de réseau de neurones.

Un module est un conteneur nommé pour tf.Variable s, d' autres tf.Module s et des fonctions qui sont applicables à l' entrée utilisateur. Par exemple peut être mis en œuvre une couche dense dans un réseau de neurones comme 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)
  

Vous pouvez utiliser la couche Dense comme on peut s'y attendre:

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

Par sous - classement tf.Module au lieu d' object tout tf.Variable ou tf.Module instances affectées à des propriétés d'objet peuvent être collectées en utilisant les variables , trainable_variables ou submodules - submodules propriété:

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

Sous - classes de tf.Module peuvent également profiter de la _flatten méthode qui peut être utilisé pour mettre en œuvre le suivi d'un autre type.

Toutes les tf.Module classes ont un associé tf.name_scope qui peut être utilisé pour les opérations du groupe dans TensorBoard et créer des hiérarchies pour les noms de variables qui peuvent faciliter le débogage. Nous vous suggérons d'utiliser le champ de nom lors de la création / paramètres imbriqués sous-modules ou des méthodes dont le graphe avant que vous pourriez vouloir vérifier dans TensorBoard. Vous pouvez entrer dans le champ de nom en utilisant explicitement with self.name_scope: ou vous pouvez annoter les méthodes ( en dehors de __init__ ) avec @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 Retourne le nom de ce module comme passé ou déterminé dans le cteur.

name_scope Retourne une tf.name_scope instance pour cette classe.
submodules Séquence de tous les sous-modules.

Les sous-modules sont des modules qui sont des propriétés de ce module, ou trouvé que les propriétés des modules qui sont propriétés de ce module (et ainsi de suite).

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 Séquence des variables trainable appartenant à ce module et ses sous-modules.

variables Séquence des variables appartenant à ce module et ses sous - modules.

méthodes

with_name_scope

Voir la source

Décorateur pour entrer automatiquement le champ du nom du module.

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)

En utilisant le module ci - dessus produirait tf.Variable s et tf.Tensor s dont les noms inclus le nom du module:

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 Procédé pour envelopper.

Retour
La méthode originale enveloppé telle qu'elle entre dans le champ du nom du module.