webentwicklung-frage-antwort-db.com.de

Tensor ist kein Element dieses Diagramms

Ich bekomme diesen Fehler

'ValueError: Tensor Tensor ("Platzhalter: 0", Form = (1, 1), dtype = int32) ist kein Element dieses Graphen. '

Der Code läuft einwandfrei ohne with tf.Graph(). as_default():. Allerdings muss ich M.sample(...) mehrmals aufrufen und jedes Mal ist der Speicher nach session.close() nicht mehr frei. Wahrscheinlich gibt es ein Speicherverlust, aber nicht sicher, wo es ist.

Ich möchte ein zuvor trainiertes neuronales Netzwerk wiederherstellen, als Standardgraph festlegen und es mehrmals (z. B. 10000) über den Standardgraphen testen, ohne es jedes Mal zu vergrößern.

Der Code lautet:

def SessionOpener(save):
    grph = tf.get_default_graph()
    sess = tf.Session(graph=grph)
    ckpt = tf.train.get_checkpoint_state(save)
    saver = tf.train.import_meta_graph('./predictor/save/model.ckpt.meta')
    if ckpt and ckpt.model_checkpoint_path:
        saver.restore(sess, ckpt.model_checkpoint_path)
        tf.global_variables_initializer().run(session=sess)
    return sess

def LoadPredictor(save):
    with open(os.path.join(save, 'config.pkl'), 'rb') as f:
        saved_args = cPickle.load(f)
    with open(os.path.join(save, 'words_vocab.pkl'), 'rb') as f:
        words, vocab = cPickle.load(f)
    model = Model(saved_args, True)
    return model, words, vocab

if __== '__main__':
    Save = './save'
    M, W, V = LoadPredictor(Save)
    Sess = SessionOpener(Save)
    Word = M.sample(Sess, W, V, 1, str(123), 2, 1, 4)
    Sess.close()

Und das Modell ist:

class Model():
    def __init__(self, args, infer=False):
        with tf.Graph().as_default():
            self.args = args
            if infer:
                args.batch_size = 1
                args.seq_length = 1

            if args.model == 'rnn':
                cell_fn = rnn.BasicRNNCell
            Elif args.model == 'gru':
                cell_fn = rnn.GRUCell
            Elif args.model == 'lstm':
                cell_fn = rnn.BasicLSTMCell
            else:
                raise Exception("model type not supported: {}".format(args.model))

            cells = []
            for _ in range(args.num_layers):
                cell = cell_fn(args.rnn_size)
                cells.append(cell)

            self.cell = cell = rnn.MultiRNNCell(cells)

            self.input_data = tf.placeholder(tf.int32, [args.batch_size, args.seq_length])
            self.targets = tf.placeholder(tf.int32, [args.batch_size, args.seq_length])
            self.initial_state = cell.zero_state(args.batch_size, tf.float32)
            self.batch_pointer = tf.Variable(0, name="batch_pointer", trainable=False, dtype=tf.int32)
            self.inc_batch_pointer_op = tf.assign(self.batch_pointer, self.batch_pointer + 1)
            self.Epoch_pointer = tf.Variable(0, name="Epoch_pointer", trainable=False)
            self.batch_time = tf.Variable(0.0, name="batch_time", trainable=False)
            tf.summary.scalar("time_batch", self.batch_time)

            def variable_summaries(var):
            """Attach a lot of summaries to a Tensor (for TensorBoard visualization)."""
                with tf.name_scope('summaries'):
                    mean = tf.reduce_mean(var)
                    tf.summary.scalar('mean', mean)
                    tf.summary.scalar('max', tf.reduce_max(var))
                    tf.summary.scalar('min', tf.reduce_min(var))


            with tf.variable_scope('rnnlm'):
                softmax_w = tf.get_variable("softmax_w", [args.rnn_size, args.vocab_size])
                variable_summaries(softmax_w)
                softmax_b = tf.get_variable("softmax_b", [args.vocab_size])
                variable_summaries(softmax_b)
                with tf.device("/cpu:0"):
                    embedding = tf.get_variable("embedding", [args.vocab_size, args.rnn_size])
                    inputs = tf.split(tf.nn.embedding_lookup(embedding, self.input_data), args.seq_length, 1)
                    inputs = [tf.squeeze(input_, [1]) for input_ in inputs]

            def loop(prev, _):
                prev = tf.matmul(prev, softmax_w) + softmax_b
                prev_symbol = tf.stop_gradient(tf.argmax(prev, 1))
                return tf.nn.embedding_lookup(embedding, prev_symbol)

            outputs, last_state = legacy_seq2seq.rnn_decoder(inputs, self.initial_state, cell, loop_function=loop if infer else None, scope='rnnlm')
            output = tf.reshape(tf.concat(outputs, 1), [-1, args.rnn_size])
            self.logits = tf.matmul(output, softmax_w) + softmax_b
            self.probs = tf.nn.softmax(self.logits)
            loss = legacy_seq2seq.sequence_loss_by_example([self.logits],
                    [tf.reshape(self.targets, [-1])],
                    [tf.ones([args.batch_size * args.seq_length])],
                    args.vocab_size)
            self.cost = tf.reduce_sum(loss) / args.batch_size / args.seq_length
            tf.summary.scalar("cost", self.cost)
            self.final_state = last_state
            self.lr = tf.Variable(0.0, trainable=False)
            tvars = tf.trainable_variables()
            grads, _ = tf.clip_by_global_norm(tf.gradients(self.cost, tvars),
                args.grad_clip)
            optimizer = tf.train.AdamOptimizer(self.lr)
            self.train_op = optimizer.apply_gradients(Zip(grads, tvars))

    def sample(self, sess, words, vocab, num=200, prime='first all', sampling_type=1, pick=0, width=4):
        def weighted_pick(weights):
            t = np.cumsum(weights)
            s = np.sum(weights)
            return(int(np.searchsorted(t, np.random.Rand(1)*s)))

        ret = ''
        if pick == 1:
            state = sess.run(self.cell.zero_state(1, tf.float32))

            if not len(prime) or prime == ' ':
                prime  = random.choice(list(vocab.keys()))
            for Word in prime.split()[:-1]:
                x = np.zeros((1, 1))
                x[0, 0] = vocab.get(Word,0)
                feed = {self.input_data: x, self.initial_state:state}
                [state] = sess.run([self.final_state], feed)

            ret = prime
            Word = prime.split()[-1]
            for n in range(num):
                x = np.zeros((1, 1))
                x[0, 0] = vocab.get(Word, 0)
                feed = {self.input_data: x, self.initial_state:state}
                [probs, state] = sess.run([self.probs, self.final_state], feed)
                p = probs[0]

                if sampling_type == 0:
                    sample = np.argmax(p)
                Elif sampling_type == 2:
                    if Word == '\n':
                        sample = weighted_pick(p)
                    else:
                        sample = np.argmax(p)
                else: # sampling_type == 1 default:
                    sample = weighted_pick(p)

                ret = words[sample]
        return ret

und die Ausgabe ist:

Traceback (most recent call last):
  File "/rcg/software/Linux/Ubuntu/16.04/AMD64/TOOLS/TENSORFLOW/1.2.1-GPU-PY352/lib/python3.5/site-packages/tensorflow/python/client/session.py", line 942, in _run
    allow_operation=False)
  File "/rcg/software/Linux/Ubuntu/16.04/AMD64/TOOLS/TENSORFLOW/1.2.1-GPU-PY352/lib/python3.5/site-packages/tensorflow/python/framework/ops.py", line 2584, in as_graph_element
    return self._as_graph_element_locked(obj, allow_tensor, allow_operation)
  File "/rcg/software/Linux/Ubuntu/16.04/AMD64/TOOLS/TENSORFLOW/1.2.1-GPU-PY352/lib/python3.5/site-packages/tensorflow/python/framework/ops.py", line 2663, in _as_graph_element_locked
    raise ValueError("Tensor %s is not an element of this graph." % obj)
ValueError: Tensor Tensor("Placeholder:0", shape=(1, 1), dtype=int32) is not an element of this graph.
pythonmachine-learningtensorflowmemory-leaksneural-network
13
ashkan

Wenn Sie eine Model erstellen, wurde die Sitzung noch nicht wiederhergestellt. Alle Platzhalter, Variablen und Operationen, die in Model.__init__ definiert sind, werden in einem new-Diagramm platziert, das sich selbst zu einem Standarddiagramm im with-Block macht. Dies ist die Schlüsselzeile: 

with tf.Graph().as_default():
  ...

Dies bedeutet, dass diese Instanz von tf.Graph() der tf.get_default_graph()-Instanz in with-Block entspricht, aber nicht davor oder danach . Von diesem Moment an gibt es zwei verschiedene Graphen.

Wenn Sie später eine Sitzung erstellen und ein Diagramm darin wiederherstellen, können Sie nicht auf die vorherige Instanz von tf.Graph() in dieser Sitzung zugreifen. Hier ist ein kurzes Beispiel:

with tf.Graph().as_default() as graph:
  var = tf.get_variable("var", shape=[3], initializer=tf.zeros_initializer)

# This works
with tf.Session(graph=graph) as sess:
  sess.run(tf.global_variables_initializer())
  print(sess.run(var))  # ok because `sess.graph == graph`

# This fails
saver = tf.train.import_meta_graph('/tmp/model.ckpt.meta')
with tf.Session() as sess:
  saver.restore(sess, "/tmp/model.ckpt")
  print(sess.run(var))   # var is from `graph`, not `sess.graph`!

Am besten können Sie damit umgehen, indem Sie allen Knoten Namen geben, z. 'input', 'target' usw. speichern Sie das Modell, und suchen Sie die Knoten im restore -Diagramm nach Namen, etwa wie folgt:

saver = tf.train.import_meta_graph('/tmp/model.ckpt.meta')
with tf.Session() as sess:
  saver.restore(sess, "/tmp/model.ckpt")      
  input_data = sess.graph.get_tensor_by_name('input')
  target = sess.graph.get_tensor_by_name('target')

Diese Methode garantiert, dass alle Knoten aus dem Graphen in der Sitzung stammen.

11
Maxim

Versuchen Sie mit: 

import tensorflow as tf
global graph,model
graph = tf.get_default_graph()

Wenn Sie vorhersagen müssen:

with graph.as_default():
     y = model.predict(X)
6
Ilyas

Wenn Sie die Funktion python aufrufen, die Tensorflow von einem externen Modul aus aufruft, stellen Sie sicher, dass das Modell nicht als globale Variable geladen wird, da es sonst möglicherweise nicht rechtzeitig zur Verwendung geladen wird Dies ist mir passiert, als ich ein Tensorflow - Modell vom Flask Server aus aufgerufen habe.

0
colby-ham

Innerhalb def LoadPredictor(save):
Fügen Sie kurz nach dem Laden des Modells model._make_predict_function() hinzu.
So wird die Funktion:

def LoadPredictor(save):
    with open(os.path.join(save, 'config.pkl'), 'rb') as f:
        saved_args = cPickle.load(f)
    with open(os.path.join(save, 'words_vocab.pkl'), 'rb') as f:
        words, vocab = cPickle.load(f)
    model = Model(saved_args, True)
    model._make_predict_function()
    return model, words, vocab
0
Prateek Gulati