Tensorflow: Wie Adam Optimizer richtig zu verwenden

Question

Jemand hat bereits eine similar question gefragt, aber die Lösung, die dort angegeben ist, funktioniert nicht für mich.

Ich versuche, Adam Optimizer in Tensorflow zu verwenden. Hier ist ein Teil meines Codes darüber:

adamOptimizer = tf.train.AdamOptimizer(learning_rate=0.001, beta1=0.9, 
      beta2=0.999, epsilon=1e-08, use_locking=False, name='Adam') 

print('Optimizer was created!') 

# Create a variable to track the global step. 
global_step = tf.Variable(0, name='global_step', trainable=False) 

#Initialize variables 
vars_to_init = ae.get_variables_to_init(n) 
vars_to_init.append(global_step) 
vars_to_init.append 

sess.run(tf.variables_initializer(vars_to_init)) 

# create an optimizer 
train_op = adamOptimizer.minimize(loss, global_step=global_step) 

Der folgende Fehler wird ausgelöst, nachdem train_op zum ersten Mal verwendet wird:

FailedPreconditionError (see above for traceback): Attempting to use uninitialized value pretrain_1/beta2_power [[Node: pretrain_1/beta2_power/read = IdentityT=DT_FLOAT, _class=["loc:@autoencoder_variables/weights1"], _device="/job:localhost/replica:0/task:0/cpu:0"]]

Wenn ich versuche, eine Linie

vars_to_init.append(beta2_power) 

hinzufügen

ich die folgende Fehlermeldung erhalten:

NameError: global name 'beta2_power' is not defined

Wenn ich einen Rat für die similar question folgen und sess.run (tf.variables_initializer (vars_to_init)) von sess.run (tf.initialize_all_variables()) ersetzen, Ich erhalte die folgende Fehlermeldung, nachdem Sie diese Zeile ausgeführt wird:

FailedPreconditionError: Attempting to use uninitialized value autoencoder_variables/biases1 [[Node: autoencoder_variables/biases1/read = IdentityT=DT_FLOAT, _class=["loc:@autoencoder_variables/biases1"], _device="/job:localhost/replica:0/task:0/cpu:0"]]

hatte ich keine Probleme, wenn ich Gradient Descent Optimierer wurde mit ...

Was mache ich falsch? Was ist der richtige Weg, diesen Optimierer zu verwenden?

EDIT Weitere Details über die Klasse autoencoder_variables zu klären:

class AutoEncoder(object): 

_weights_str = "weights{0}" 
_biases_str = "biases{0}" 

def __init__(self, shape, sess): 

    self.__shape = shape 
    self.__num_hidden_layers = len(self.__shape) - 2 

    self.__variables = {} 
    self.__sess = sess 

    self._setup_variables() 

@property 
def shape(self): 
    return self.__shape 

@property 
def num_hidden_layers(self): 
    return self.__num_hidden_layers 

@property 
def session(self): 
    return self.__sess 

def __getitem__(self, item): 

return self.__variables[item] 

def __setitem__(self, key, value): 

self.__variables[key] = value 

def _setup_variables(self): 
with tf.name_scope("autoencoder_variables"): 
    for i in xrange(self.__num_hidden_layers + 1): 
    # Train weights 
    name_w = self._weights_str.format(i + 1) 
    w_shape = (self.__shape[i], self.__shape[i + 1]) 
    a = tf.mul(4.0, tf.sqrt(6.0/(w_shape[0] + w_shape[1]))) 
    w_init = tf.random_uniform(w_shape, -1 * a, a) 
    self[name_w] = tf.Variable(w_init, 
           name=name_w, 
           trainable=True) 
    # Train biases 
    name_b = self._biases_str.format(i + 1) 
    b_shape = (self.__shape[i + 1],) 
    b_init = tf.zeros(b_shape) 
    self[name_b] = tf.Variable(b_init, trainable=True, name=name_b) 

    if i <= self.__num_hidden_layers: 

     # Hidden layer fixed weights (after pretraining before fine tuning) 
     self[name_w + "_fixed"] = tf.Variable(tf.identity(self[name_w]), 
              name=name_w + "_fixed", 
              trainable=False) 

     # Hidden layer fixed biases 
     self[name_b + "_fixed"] = tf.Variable(tf.identity(self[name_b]), 
              name=name_b + "_fixed", 
              trainable=False) 

     # Pretraining output training biases 
     name_b_out = self._biases_str.format(i + 1) + "_out" 
     b_shape = (self.__shape[i],) 
     b_init = tf.zeros(b_shape) 
     self[name_b_out] = tf.Variable(b_init, 
            trainable=True, 
            name=name_b_out) 

def _w(self, n, suffix=""): 
    return self[self._weights_str.format(n) + suffix] 

def _b(self, n, suffix=""): 
    return self[self._biases_str.format(n) + suffix] 

def get_variables_to_init(self, n): 
    assert n > 0 
    assert n <= self.__num_hidden_layers + 1 

    vars_to_init = [self._w(n), self._b(n)] 

    if n <= self.__num_hidden_layers: 
    vars_to_init.append(self._b(n, "_out")) 

    if 1 < n <= self.__num_hidden_layers+1: 
    # Fixed matrices for learning of deeper layers 
    vars_to_init.append(self._w(n - 1, "_fixed")) 
    vars_to_init.append(self._b(n - 1, "_fixed")) 

    return vars_to_init 

Answer 1

Das Problem war, dass ich einen Variablenwert um wurde mit einem anderen Variablen initialisiert wird (es wurde einen Fehler der Verwendung von nicht initialisierten Variablen während der Initialisierung) .

Statt eine weitere Variable bei der Initialisierung des Verwendens

self[name_b + "_fixed"] = tf.Variable(tf.identity(self[name_b]), 
              name=name_b + "_fixed", 
              trainable=False) 

ich initialisieren es zufällig

self[name_b + "_fixed"] = tf.Variable(init_b, 
              name=name_b + "_fixed", 
              trainable=False) 

Und es auf eine andere Variable zuweisen, sobald sie ausgebildet wurde:

ae[name_w + "_fixed"] = tf.identity(ae[name_w])