Mehrere Modelle in demselben Diagramm erstellen

Question

Ich versuche, zwei ähnliche Modelle zu erstellen, die unterschiedliche Ausgabetypen vorhersagen. Man sagt zwischen zwei Kategorien voraus und die andere hat sechs Ausgabekategorien. Ihre Eingaben sind die gleichen und sie sind beide LSTM RNN.

Ich habe das Training getrennt und in jeder ihrer Dateien, model1.py, model2.py, in separaten Funktionen vorausgesagt.

Ich habe den Fehler gemacht Variablen in jedem Modell die gleiche Sache zu benennen, so dass, wenn ich preced1 und predict2 von model1 bzw. model2 aufrufen, bekomme ich folgenden Namensraumfehler: ValueError: Variable W existiert bereits, nicht erlaubt. Wollten Sie in VarScope reuse = True setzen? Ursprünglich definiert unter:

W ist der Name der Matrix der Gewichte.

Gibt es eine gute Möglichkeit, diese Vorhersagen vom selben Ort aus auszuführen? Ich habe versucht, die beteiligten Variablen umzubenennen, aber immer noch den folgenden Fehler zu erhalten. Es scheint nicht möglich zu sein, eine lstm_cell für die Erstellung zu nennen, oder?

ValueError: Variable RNN/BasicLSTMCell/Linear/Matrix already exists 

EDIT: Nach rund Scoping model1pred und model2pred in den Vorhersagen Datei ich folgende Fehlermeldung erhalten, wenn() dann model2pred()

tensorflow.python.framework.errors.NotFoundError: Tensor name model1/model1/BasicLSTMCell/Linear/Matrix" not found in checkpoint files './variables/model1.chk 

EDIT model1pred Berufung: Der Code enthalten ist hier. Der Code in model2.py fehlt, entspricht aber in model1.py mit Ausnahme von n_classes = 2, und innerhalb der Funktion dynamicRNN und innerhalb von pred wird der Bereich auf 'model2' gesetzt.

LÖSUNG: Das Problem war das Diagramm, das der Sparer versuchte, eingeschlossene Variablen von der ersten pred() - Ausführung wiederherzustellen. Ich war in der Lage, Aufrufe von pred-Funktionen in verschiedene Graphen zu packen, um das Problem zu lösen.

In collect Prognosen Datei:

def model1pred(test_x, test_seqlen): 
    from model1 import pred 
    with tf.Graph().as_default(): 
     return pred(test_x, test_seqlen) 

def model2pred(test_x, test_seqlen): 
    from model2 import pred 
    with tf.Graph().as_default(): 
     return pred(test_x, test_seqlen) 

##Import test_x, test_seqlen 

probs1, preds1 = model1pred(test_x, test_seq) 
probs2, cpreds2 = model2Pred(test_x, test_seq) 

In model1.py

def dynamicRNN(x, seqlen, weights, biases): 
    n_steps = 10 
    n_input = 14 
    n_classes = 6 
    n_hidden = 100 

    # Prepare data shape to match `rnn` function requirements 
    # Current data input shape: (batch_size, n_steps, n_input) 
    # Required shape: 'n_steps' tensors list of shape (batch_size, n_input) 

    # Permuting batch_size and n_steps 
    x = tf.transpose(x, [1, 0, 2]) 
    # Reshaping to (n_steps*batch_size, n_input) 
    x = tf.reshape(x, [-1,n_input]) 
    # Split to get a list of 'n_steps' tensors of shape (batch_size, n_input) 
    x = tf.split(0, n_steps, x) 

    # Define a lstm cell with tensorflow 
    lstm_cell = rnn_cell.BasicLSTMCell(n_hidden, forget_bias=1.0) 

    # Get lstm cell output, providing 'sequence_length' will perform dynamic calculation. 
    outputs, states = tf.nn.rnn(lstm_cell, x, dtype=tf.float32, sequence_length=seqlen) 

    # When performing dynamic calculation, we must retrieve the last 
    # dynamically computed output, i.e, if a sequence length is 10, we need 
    # to retrieve the 10th output. 
    # However TensorFlow doesn't support advanced indexing yet, so we build 
    # a custom op that for each sample in batch size, get its length and 
    # get the corresponding relevant output. 

    # 'outputs' is a list of output at every timestep, we pack them in a Tensor 
    # and change back dimension to [batch_size, n_step, n_input] 
    outputs = tf.pack(outputs) 
    outputs = tf.transpose(outputs, [1, 0, 2]) 

    # Hack to build the indexing and retrieve the right output. 
    batch_size = tf.shape(outputs)[0] 
    # Start indices for each sample 
    index = tf.range(0, batch_size) * n_steps + (seqlen - 1) 
    # Indexing 
    outputs = tf.gather(tf.reshape(outputs, [-1, n_hidden]), index) 

    # Linear activation, using outputs computed above 
    return tf.matmul(outputs, weights['out']) + biases['out'] 

def pred(test_x, test_seqlen): 
    with tf.Session() as sess: 
     n_steps = 10 
     n_input = 14 
     n_classes = 6 
     n_hidden = 100 
     weights = {'out': tf.Variable(tf.random_normal([n_hidden, n_classes]), name='W1')} 
     biases = {'out': tf.Variable(tf.random_normal([n_classes]), name='b1')} 
     x = tf.placeholder("float", [None, n_steps, n_input]) 
     y = tf.placeholder("float", [None, n_classes]) 
     seqlen = tf.placeholder(tf.int32, [None]) 

     pred = dynamicRNN(x, seqlen, weights, biases) 
     saver = tf.train.Saver(tf.all_variables()) 
     y_p =tf.argmax(pred,1) 

     init = tf.initialize_all_variables() 
     sess.run(init) 

     saver.restore(sess,'./variables/model1.chk') 
     y_prob, y_pred= sess.run([pred, y_p], feed_dict={x: test_x, seqlen: test_seqlen}) 
     y_prob = np.array([softmax(x) for x in y_prob]) 
     return y_prob, y_pred 

'

Answer 1

Sie können dies tun, indem with tf.variable_scope(): Blöcke um die beiden Stücke von Modellbau Code hinzufügen. Dies hat den Effekt, dass den Variablennamen ein anderes Präfix vorangestellt wird, wodurch der Konflikt vermieden wird.

Zum Beispiel (unter Verwendung der model1pred() und model2pred() Funktionen in Ihrer Frage definiert):

with tf.variable_scope('model1'): 
    # Variables created in here will be named 'model1/W', etc. 
    probs1, preds1 = model1pred(test_x, test_seq) 

with tf.variable_scope('model2'): 
    # Variables created in here will be named 'model2/W', etc. 
    probs2, cpreds2 = model2Pred(test_x, test_seq) 

Weitere Einzelheiten finden Sie die eingehenden HOWTO on variable sharing in TensorFlow.