Ich erhalte den gleichen Fehler, wenn ich versuche, das Übersetzungsbeispiel auszuführen (auch wenn ich den kleinen Selbsttest durchführe), der hier zu finden ist: https://github.com/tensorflow/models/tree/master/tutorials/rnn/translate

Ich bin auf das gleiche Problem gestoßen. Wenn Sie alle die kompilierte Version auf dem Master-Zweig verwenden, glaube ich, dass wir das gleiche Problem haben, das durch den letzten Commit verursacht wurde. Wie die Commit-Nachricht sagt:

Lassen Sie alle RNNCells in tf.contrib.rnn sich wie tf.layers Layers verhalten, aber mit strengerer Semantik für no
w:

1. Bei der ersten Verwendung von __call__ wird der verwendete Bereich in der Zelle gespeichert. Die RNNCell versucht, Gewichtungen in diesem Bereich zu erstellen, aber wenn einige bereits festgelegt sind, wird ein Fehler ausgelöst, es sei denn, die RNNCell wurde mit dem Argument reuse=True erstellt.

2. Eine nachfolgende Verwendung von __call__ derselben Zelleninstanz muss sich im selben Bereich befinden.
   Ist dies nicht der Fall, wird ein Fehler ausgelöst.

In meinem Fall, in dem das ptb-Tutorial ausgeführt wird, besteht die Lösung darin, in Zeile 112 einfach einen Parameter mit dem Namen reuse hinzuzufügen:

def lstm_cell():
  return tf.contrib.rnn.BasicLSTMCell(
      size, forget_bias=0.0, state_is_tuple=True, reuse=tf.get_variable_scope().reuse)

Dann funktioniert es.

@ebrevdo Könntest du dir das bitte ansehen?

Das Problem tritt bei mir auf, wenn ich Windows/GPU Build 105 im Shakespeare RNN Repo verwende.

Beim Ausführen des Codes mit Win 1.0.0/GPU Release gibt es kein Problem.

Dieses Repo scheint auf tf 1.0 ausgerichtet zu sein, nicht auf Zwischenversionen.

Am 8. März 2017 um 15:56 Uhr schrieb „Tom Wanzek“ [email protected] :

Das Problem repliziert sich für mich, wenn ich Windows/GPU Build 105 auf dem Shakespeare verwende
RNN-Repository https://github.com/martin-gorner/tensorflow-rnn-shakespeare .

Beim Ausführen des Codes mit Win 1.0.0/GPU Release gibt es kein Problem.

—
Sie erhalten dies, weil Sie erwähnt wurden.
Antworten Sie direkt auf diese E-Mail und zeigen Sie sie auf GitHub an
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285209555 ,
oder den Thread stumm schalten
https://github.com/notifications/unsubscribe-auth/ABtim5ansaL1KN51T4nCaqLnqw2QHN4Wks5rj0BBgaJpZM4MWl4f
.

@tongda , ich verwende die Release-Version von Tensorflow 1.0 und arbeite unter MacOS im CPU-Modus. Ich werde zum Master-Zweig wechseln, um zu sehen, ob es funktioniert, indem ich den Parameter "Wiederverwendung" hinzufüge, danke.

doncat99: Wenn Sie dies tun, stellen Sie bitte sicher, dass Ihr Code die Tensorflow-Version abfragt
und setzt ein Flag, wenn die Version niedriger als die Master-Zweig-Version ist.
Sie müssen möglicherweise Folgendes überprüfen:

aus tensorflow.core-Importversionen
Versionen.GIT_VERSION

Am Mittwoch, den 8. März 2017 um 18:58 Uhr schrieb doncat99 [email protected] :

@tongda https://github.com/tongda , ich verwende die Release-Version von
Tensorflow 1.0, läuft auf MacOS im CPU-Modus. Ich werde zum Master wechseln
Verzweigen Sie, um zu sehen, ob es funktioniert, indem Sie den Parameter "Wiederverwendung" hinzufügen, danke.

—
Sie erhalten dies, weil Sie erwähnt wurden.
Antworten Sie direkt auf diese E-Mail und zeigen Sie sie auf GitHub an
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285240438 ,
oder den Thread stumm schalten
https://github.com/notifications/unsubscribe-auth/ABtim66cU9e16lgD-2D0QLGcQCiHbV0zks5rj2rbgaJpZM4MWl4f
.

@ebrevdo Was wären also die vorgeschlagenen Änderungen am Shakepeare RNN, damit es mit der stabilen Zwischenversion funktioniert?

Hier ist der wichtigste architektonische Abschnitt des Codes, der jetzt mit Build#105 fehlschlägt:

#
# the model (see FAQ in README.md)
#
lr = tf.placeholder(tf.float32, name='lr')  # learning rate
pkeep = tf.placeholder(tf.float32, name='pkeep')  # dropout parameter
batchsize = tf.placeholder(tf.int32, name='batchsize')

# inputs
X = tf.placeholder(tf.uint8, [None, None], name='X')    # [ BATCHSIZE, SEQLEN ]
Xo = tf.one_hot(X, ALPHASIZE, 1.0, 0.0)                 # [ BATCHSIZE, SEQLEN, ALPHASIZE ]
# expected outputs = same sequence shifted by 1 since we are trying to predict the next character
Y_ = tf.placeholder(tf.uint8, [None, None], name='Y_')  # [ BATCHSIZE, SEQLEN ]
Yo_ = tf.one_hot(Y_, ALPHASIZE, 1.0, 0.0)               # [ BATCHSIZE, SEQLEN, ALPHASIZE ]
# input state
Hin = tf.placeholder(tf.float32, [None, INTERNALSIZE*NLAYERS], name='Hin')  # [ BATCHSIZE, INTERNALSIZE * NLAYERS]

# using a NLAYERS=3 layers of GRU cells, unrolled SEQLEN=30 times
# dynamic_rnn infers SEQLEN from the size of the inputs Xo

onecell = rnn.GRUCell(INTERNALSIZE)
dropcell = rnn.DropoutWrapper(onecell, input_keep_prob=pkeep)
multicell = rnn.MultiRNNCell([dropcell for _ in range(NLAYERS)], state_is_tuple=False)
multicell = rnn.DropoutWrapper(multicell, output_keep_prob=pkeep)
Yr, H = tf.nn.dynamic_rnn(multicell, Xo, dtype=tf.float32, initial_state=Hin)
# Yr: [ BATCHSIZE, SEQLEN, INTERNALSIZE ]
# H:  [ BATCHSIZE, INTERNALSIZE*NLAYERS ] # this is the last state in the sequence

Ich scheine keine Dokumentation zu einem reuse -Flag zu finden?

Vielen Dank im Voraus.

Benutzen:

multicell = rnn.MultiRNNCell([rnn.DropoutWrapper(rnn.GRUCell(INTERNALSIZE),
input_keep_prob=pkeep) für _ in range(NLAYERS)], state_is_tuple=False)

Dadurch wird für jede Ebene ein separates Grucell-Objekt erstellt.

Am 10. März 2017 um 7:44 Uhr schrieb „Tom Wanzek“ [email protected] :

@ebrevdo https://github.com/ebrevdo Also, was wäre der Vorschlag
Änderungen am Shakepeare RNN, damit es mit dem Zwischenprodukt arbeiten kann
stabile Version?

Hier ist der Schlüsselarchitekturabschnitt des Codes, der jetzt fehlschlägt
Build#105:

das Modell (siehe FAQ in README.md)

lr = tf.placeholder(tf.float32, name='lr') # Lernrate
pkeep = tf.placeholder(tf.float32, name='pkeep') # Dropout-Parameter
batchsize = tf.placeholder(tf.int32, name='batchsize')

Eingänge

X = tf.placeholder(tf.uint8, [None, None], name='X') # [ BATCHSIZE, SEQLEN ]
Xo = tf.one_hot(X, ALPHASIZE, 1.0, 0.0) # [ BATCHSIZE, SEQLEN, ALPHASIZE ]# erwartete Ausgaben = gleiche Sequenz um 1 verschoben, da wir versuchen, das nächste Zeichen vorherzusagen
Y_ = tf.placeholder(tf.uint8, [None, None], name='Y_') # [ BATCHSIZE, SEQLEN ]
Yo_ = tf.one_hot(Y_, ALPHASIZE, 1.0, 0.0) # [ BATCHSIZE, SEQLEN, ALPHASIZE ]# Eingangszustand
Hin = tf.placeholder(tf.float32, [None, INTERNALSIZE*NLAYERS], name='Hin') # [ BATCHSIZE, INTERNALSIZE * NLAYERS]

unter Verwendung von NLAYERS = 3 Schichten von GRU-Zellen, entrollt SEQLEN = 30 Mal # dynamic_rnn leitet SEQLEN von der Größe der Eingaben Xo ab

onecell = rnn.GRUCell(INTERNALSIZE)
dropcell = rnn.DropoutWrapper (onecell, input_keep_prob=pkeep)
multicell = rnn.MultiRNNCell([dropcell for _ in range(NLAYERS)], state_is_tuple=False)
multicell = rnn.DropoutWrapper (multicell, output_keep_prob=pkeep)
Yr, H = tf.nn.dynamic_rnn(multicell, Xo, dtype=tf.float32, initial_state=Hin)# Yr: [ BATCHSIZE, SEQLEN, INTERNALSIZE ]# H: [ BATCHSIZE, INTERNALSIZE*NLAYERS ] # Dies ist der letzte Zustand in der Folge

Ich scheine keine Dokumentation zu einem Wiederverwendungs-Flag zu finden?

Vielen Dank im Voraus.

—
Sie erhalten dies, weil Sie erwähnt wurden.
Antworten Sie direkt auf diese E-Mail und zeigen Sie sie auf GitHub an
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285702372 ,
oder den Thread stumm schalten
https://github.com/notifications/unsubscribe-auth/ABtim6MOOCbx3RJEJe8PQBDXGVIXTGPmks5rkW_jgaJpZM4MWl4f
.

Ich verstehe nicht, warum ich diesen Fehler mit dem seq2seq-Tutorial-Modell bekomme :

cell = tf.contrib.rnn.MultiRNNCell([single_cell() for _ in range(num_layers)])

Quelle

wo die Zelle mit erstellt wird

def single_cell():
    return tf.contrib.rnn.GRUCell(size)

@ebrevdo Vielen Dank, dass Sie auf dieses Problem zurückgekommen sind. Leider belässt die vorgeschlagene Änderung die Dinge beim Alten, mit dem oben genannten Fehler. Angesichts des obigen Kommentars zum seq2seq-Tutorial vermute ich, dass wir alle im selben Boot sitzen?

Bist du sicher, dass es genau der gleiche Fehler ist? Bitte kopieren und hier einfügen.

Mein Fehler, ich habe gerade den Änderungsprozess für den relevanten Code erneut durchlaufen (von Grund auf neu) und ihn wie vorgeschlagen erneut ausgeführt. Der Fehler wurde tatsächlich behoben und der alte Barde halluziniert jetzt ganz gut 👍

Also, thx, ich bin mir nicht sicher, was ich gestern falsch gemacht habe, aber es lag eindeutig an mir.

Ich bin auf das gleiche Problem gestoßen, als ich die Release-Version von Tensorflow 1.0 verwendet und unter MacOS im CPU-Modus gearbeitet habe. Auch wenn ich den Parameter "reuse" hinzugefügt habe

def cell():
    return tf.contrib.rnn.BasicLSTMCell(rnn_size,state_is_tuple=True,reuse=tf.get_variable_scope().reuse)

muticell = tf.contrib.rnn.MultiRNNCell([cell for _ in range(num_layers)], state_is_tuple=True)

Ihr Multicell sieht falsch aus ... Sie sollten "cell() for _ in" verwenden
Palette(...)"

Am Do, 16. März 2017 um 20:29 Uhr schrieb cuiming [email protected] :

Ich bin auf das gleiche Problem gestoßen, als ich die Release-Version von Tensorflow 1.0 verwendet habe
und unter MacOS im CPU-Modus arbeiten. Auch wenn Sie den Parameter "Wiederverwendung" hinzufügen

def-Zelle():
return tf.contrib.rnn.BasicLSTMCell(rnn_size,state_is_tuple=True,reuse=tf.get_variable_scope().reuse)

muticell = tf.contrib.rnn.MultiRNNCell([cell for _ in range(num_layers)], state_is_tuple=True)

—
Sie erhalten dies, weil Sie erwähnt wurden.
Antworten Sie direkt auf diese E-Mail und zeigen Sie sie auf GitHub an
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-287257629 ,
oder den Thread stumm schalten
https://github.com/notifications/unsubscribe-auth/ABtim3A6JQr8ptRKrdiDW_kgNRIFkHGlks5rmf4WgaJpZM4MWl4f
.

Ich habe versucht, das Übersetzungsbeispiel auszuführen: python2.7 translate.py --data_dir data/ --train_dir train/ --size=256 --num_layers=2 --steps_per_checkpoint=50

Es scheint, dass die Art und Weise, MultiRNNCell zu verwenden, richtig ist:
cell = tf.contrib.rnn.MultiRNNCell([single_cell() for _ in range(num_layers)])

Aber ich habe den gleichen Fehler:
ValueError: Versuch, RNNCell wiederzuverwendenmit einem anderen Variablenbereich als bei der ersten Verwendung. Die erste Verwendung der Zelle erfolgte mit dem Bereich „embedding_attention_seq2seq/embedding_attention_decoder/attention_decoder/multi_rnn_cell/cell_0/gru_cell“, dieser Versuch erfolgt mit dem Bereich „embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_0/gru_cell“. Bitte erstellen Sie eine neue Instanz der Zelle, wenn Sie einen anderen Satz von Gewichtungen verwenden möchten. Wenn Sie zuvor Folgendes verwendet haben: MultiRNNCell([GRUCell(...)] * num_layers), wechseln Sie zu: MultiRNNCell([GRUCell(...) for _ in range(num_layers)]). Wenn Sie zuvor dieselbe Zelleninstanz sowohl als Vorwärts- als auch als Rückwärtszelle eines bidirektionalen RNN verwendet haben, erstellen Sie einfach zwei Instanzen (eine für Vorwärts, eine für Rückwärts). Im Mai 2017 werden wir damit beginnen, das Verhalten dieser Zelle so umzustellen, dass vorhandene gespeicherte Gewichtungen verwendet werden, falls vorhanden, wenn sie mit scope=None aufgerufen wird (was zu einer stillen Modellverschlechterung führen kann, sodass dieser Fehler bis dahin bestehen bleibt).

@bowu - hattest du damit Glück? Wenn Sie es noch nicht ausprobiert haben, installieren Sie Tensorflow von der neuesten Quelle neu. Es gab unter anderem einige Änderungen an einigen der core_rnn-Dateien. funktioniert jetzt bei mir.

@robmsylvester Ich installiere Tensorflow von der neuesten Quelle neu, immer noch der gleiche Fehler. Ich war auf Branch Master und der letzte Commit ist commit 2a4811054a9e6b83e1f5a2705a92aab50e151b13 . Was ist das letzte Commit, wenn Sie Ihr Repo erstellen?

Hallo, ich verwende Tensorflow r1.0 mit GPU, die mit Source erstellt wurde. Ich versuche, dem unmodifizierten Seq2Seq-Übersetzungs-Tutorial zu folgen, aber ich erhalte den gleichen Fehler. dh

ValueError: Versuch, RNNCell wiederzuverwendenmit einem anderen Variablenbereich als bei der ersten Verwendung. Die erste Verwendung der Zelle erfolgte mit dem Geltungsbereich 'embedding_attention_seq2seq/embedding_attention_decoder/attention_decoder/multi_rnn_cell/cell_0/gru_cell', dieser Versuch erfolgt mit dem Geltungsbereich 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_0/gru_cell'.....

Der relevante Teil des Codes in meinem seq2seq_model.py ist:

 # Create the internal multi-layer cell for our RNN.
    def single_cell():
      return tf.contrib.rnn.GRUCell(size)
    if use_lstm:
      def single_cell():
        return tf.contrib.rnn.BasicLSTMCell(size)
    cell = single_cell()
    if num_layers > 1:
      cell = tf.contrib.rnn.MultiRNNCell([single_cell() for _ in range(num_layers)])

Was kann ich tun, um das Problem zu lösen?

Das Hinzufügen von "reuse=tf.get_variable_scope().reuse" zum Aufruf, bei dem die GRUCell erstellt wird, hilft nicht.

Danke vielmals!

@prashantserai - sehen Sie, was passiert, wenn Sie die MultiRNNCell-Leitung von oben entfernen, wodurch Ihr Netzwerk effektiv nur eine Ebene wird. Funktioniert es dann? Es könnte irgendwo in MultiRNNCell ein Fehler sein. Ich habe darüber kürzlich irgendwo gelesen, wahrscheinlich bei Stapelüberlauf.

Wenn Sie das gestapelte lstm/gru selbst implementieren, erhalten Sie diesen Fehler nicht und können dieselbe Funktionalität implementieren (eigentlich mehr, da Sie mit bidirektionalen Architekturen, seltsamen Rest- und Skip-Verbindungen usw. tun können, was Sie wollen .)

@robmsylvester Derselbe Fehler blieb auch dann bestehen, als ich es mit num_layers=1 versuchte, wodurch diese Zeile effektiv übersprungen werden sollte. Irgendwelche anderen Ideen? Danke für die Eingabe.

Hmmm. Eine Sache, die mir auffällt, ist in der referenzierten Legacy-seq2seq-Datei:

encoder_cell = copy.deepcopy(cell)

Diese Leitung scheint verwendet zu werden, da dieselbe Architektur sowohl auf der Codierer- als auch auf der Decodiererseite verwendet wird. Sie erstellen eine Kopie der Zelle und leiten dann das Zellenargument an die Einbettungsfunktion des Aufmerksamkeits-Decoders und dann an den Aufmerksamkeits-Decoder selbst weiter.

Was passiert, wenn Sie die Encoder-Zelle UND die Decoder-Zelle explizit in Ihrer seq2seq-Modelldatei erstellen und beide an die Legacy-Bibliotheksdatei weitergeben und die kleinen Anpassungen an den Funktionen und ihren Argumenten vornehmen?

@robmsylvester sollten Änderungen an den Bereichen der Zellen nicht funktionieren? Bei den anderen beiden Beispielen funktioniert es auch. Meiner Meinung nach wäre dies ein sehr hässlicher Workaround; es muss eine sauberere Lösung geben; vielleicht übersehen wir etwas? (Ich habe den gleichen Fehler auch im seq2seq-Tutorial erhalten und alle oben genannten Lösungen ausprobiert).

@iamgroot42 - Ja, diese "Lösung" ist zugegebenermaßen sehr hässlich, aber mehr noch, wenn man versucht, herauszufinden, wo ein Problem liegen könnte. Ich werde in ein paar Stunden damit spielen und sehen, ob ich etwas aufspüren kann.

Tatsächlich ist copy.deepcopy da, weil dies Legacy-Funktionen sind und
Wir haben nicht die Ressourcen, um sie zu warten/aktualisieren. Wenn Sie möchten
Führen Sie eine abwärtskompatible Änderung ein, die es dem Benutzer ermöglicht, a
zweite Zelle für den Dekodierungsschritt, und wenn es keine ist, dann auf die zurückgreifen
deepcopy, dann würde ich gerne die PR überprüfen. Denken Sie daran, es würde
muss eine abwärtskompatible Änderung sein.

Am Dienstag, 4. April 2017 um 11:38 Uhr, Rob Sylvester [email protected]
schrieb:

@iamgroot42 https://github.com/iamgroot42 - Ja, diese „Lösung“ ist
zugegebenermaßen sehr hässlich, aber eher nur versuchen, wo ein Problem zu jagen
mag sein. Ich werde in ein paar Stunden damit spielen und sehen, ob ich etwas verfolgen kann
Nieder.

—
Sie erhalten dies, weil Sie erwähnt wurden.
Antworten Sie direkt auf diese E-Mail und zeigen Sie sie auf GitHub an
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-291593289 ,
oder den Thread stumm schalten
https://github.com/notifications/unsubscribe-auth/ABtim1QHTDhOC_zT6cKtmUFPOit5Yjn7ks5rso5CgaJpZM4MWl4f
.

@ebrevdo - Ich werde darüber nachdenken. Ich habe einen Übersetzer, der ziemlich ähnlich wie dieser funktioniert, aber Zellen über eine separate Klasse erstellt, die das Einfügen von bidirektionalen Ebenen ermöglicht, wo Sie möchten, Residuen, wo Sie möchten, das Zusammenführen von Eingaben mit concat vs. sum und ein paar andere Dinge. Ich denke, ich könnte meine Klasse ziemlich einfach zu diesem Tutorial migrieren, indem ich statische RNNs verwende. Ich lasse es dich wissen.

@ebrevdo Ich verwende Tensorflow r1.0 (tensorflow-1.0.1-cp36-cp36m-linux_x86_64) auf Red Hat und habe die neueste Version des Übersetzungs-Tutorials von Github.

Schade, dass das Übersetzungstutorial nicht mit TF 1.0 funktioniert. Das sollten wir beheben. @lukaszkaiser kannst du mal schauen? Wir arbeiten an einem neuen Tutorial, aber es dauert noch ein paar Wochen und erfordert eine nächtliche Version von TensorFlow (oder TF 1.1 oder 1.2), um zu funktionieren.

(lukasz; es ist schwer für mich, anhand der verschiedenen Kommentare zu erkennen, welcher Teil des Tutorials in TF 1.0 fehlerhaft ist. Gibt es eine Chance, dass Sie die Zeile identifizieren und ich helfen kann, sie zum Laufen zu bringen?)

@ebrevdo Es ist dieses Tutorial. Der Fehler liegt in dieser Ansammlung von Linien. Die hier übergebenen Zellen werden sowohl für die Rückwärts- als auch für die Vorwärtsphase des Legacy-seq2seq-Modells verwendet, das einen Fehler auslöst, weil dieselben Zellen mit unterschiedlichen Bereichen verwendet werden.

@iamgroot42 möchtest du eine PR mit den erforderlichen Änderungen machen? Das wäre toll, dazu habe ich momentan nicht die Zyklen selbst. Danke!

Mir ist aufgefallen, dass TF 1.0 gut mit der neuesten Version des Übersetzungs-Tutorials funktioniert, wenn es aus der Quelle im Zweig remotes/origin/r1.0 kompiliert wird

$ git clone https://github.com/tensorflow/tensorflow
$ cd tensorflow
$ git checkout remotes/origin/r1.0

dann bauen und installieren Sie TensorFlow, es funktioniert gut.

Auf dem Zweig remotes/origin/r1.1 tritt der Fehler „anderer Variablenbereich“ auf.
Ich habe den Code wie von @robmsylvester vorgeschlagen geändert

Was passiert, wenn Sie die Encoder-Zelle UND die Decoder-Zelle explizit in Ihrer seq2seq-Modelldatei erstellen und beide an die Legacy-Bibliotheksdatei weitergeben und die kleinen Anpassungen an den Funktionen und ihren Argumenten vornehmen?

und bei mir funktioniert es jetzt.

@oxwsds der Tensorflow, den ich verwende, ist 1.0.1, also liegt vielleicht ein Fehler vor.

Ich hatte versucht, was @robmsylvester damals tatsächlich vorgeschlagen hat.. und das Training hatte begonnen (2 Tage 13 Stunden jetzt geschafft).. Es schlägt beim Decodieren jedoch mit dem Fehler fehl:

  File "/homes/3/serai/.conda/envs/tensorflow_r1.0_gpu/lib/python3.6/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", line 883, in embedding_attention_seq2seq
    initial_state_attention=initial_state_attention)
  File "/homes/3/serai/.conda/envs/tensorflow_r1.0_gpu/lib/python3.6/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", line 787, in embedding_attention_decoder
    initial_state_attention=initial_state_attention)
  File "/homes/3/serai/.conda/envs/tensorflow_r1.0_gpu/lib/python3.6/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", line 686, in attention_decoder
    cell_output, state = cell(x, state)
  File "/homes/3/serai/.conda/envs/tensorflow_r1.0_gpu/lib/python3.6/site-packages/tensorflow/contrib/rnn/python/ops/core_rnn_cell_impl.py", line 796, in __call__
    % (len(self.state_size), state))
ValueError: Expected state to be a tuple of length 3, but received: Tensor("model_with_buckets/embedding_attention_seq2seq/rnn/gru_cell_4/add:0", shape=(?, 1024), dtype=float32)

Hast du versucht zu decodieren?

@prashantserai Weiß nicht genau, aber was du getroffen hast, scheint ein anderes Problem zu sein.

@prashantserai Wenn es nur beim Dekodieren fehlschlägt, hat es vielleicht etwas mit der Verwendung einer Stapelgröße von eins zu tun? Wird das Modell immer noch trainiert, wenn Sie die Stapelgröße während des Trainings auf eins verringern?

@bowu Gleicher Fehler hier. Mac OX Sierra, TensorFlow 1.1.0-rc1, Python 2.7.10 und Python 3.6.1.

@robmsylvester es hat auch erfolgreich mit einer Stapelgröße von eins trainiert, ist aber beim Decodieren auf die gleiche oder ähnliche Weise fehlgeschlagen. Hier ist eine vollständige Rückverfolgung seq2seq_f (was eine der modifizierten Funktionen war) (der #prashant-Kommentar aus meinem Code, um eine modifizierte Zeile anzuzeigen, ist Teil der Ablaufverfolgung)

2017-04-10 11:32:27.447042: I tensorflow/core/common_runtime/gpu/gpu_device.cc:887] Found device 0 with properties: 
name: GeForce GTX 780 Ti
major: 3 minor: 5 memoryClockRate (GHz) 0.928
pciBusID 0000:42:00.0
Total memory: 2.95GiB
Free memory: 2.88GiB
2017-04-10 11:32:27.447094: I tensorflow/core/common_runtime/gpu/gpu_device.cc:908] DMA: 0 
2017-04-10 11:32:27.447102: I tensorflow/core/common_runtime/gpu/gpu_device.cc:918] 0:   Y 
2017-04-10 11:32:27.447118: I tensorflow/core/common_runtime/gpu/gpu_device.cc:977] Creating TensorFlow device (/gpu:0) -> (device: 0, name: GeForce GTX 780 Ti, pci bus id: 0000:42:00.0)
Traceback (most recent call last):
  File "translate.py", line 322, in <module>
    tf.app.run()
  File "/homes/3/serai/.conda/envs/tensorflow_r1.0_gpu/lib/python3.6/site-packages/tensorflow/python/platform/app.py", line 48, in run
    _sys.exit(main(_sys.argv[:1] + flags_passthrough))
  File "translate.py", line 317, in main
    decode()
  File "translate.py", line 248, in decode
    model = create_model(sess, True)
  File "translate.py", line 136, in create_model
    dtype=dtype)
  File "/data/data6/scratch/serai/models/tutorials/rnn/translate/seq2seq_model.py", line 168, in __init__
    softmax_loss_function=softmax_loss_function)
  File "/homes/3/serai/.conda/envs/tensorflow_r1.0_gpu/lib/python3.6/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", line 1203, in model_with_buckets
    decoder_inputs[:bucket[1]])
  File "/data/data6/scratch/serai/models/tutorials/rnn/translate/seq2seq_model.py", line 167, in <lambda>
    self.target_weights, buckets, lambda x, y: seq2seq_f(x, y, True),
  File "/data/data6/scratch/serai/models/tutorials/rnn/translate/seq2seq_model.py", line 144, in seq2seq_f
    dtype=dtype) #prashant
  File "/homes/3/serai/.conda/envs/tensorflow_r1.0_gpu/lib/python3.6/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", line 883, in embedding_attention_seq2seq
    initial_state_attention=initial_state_attention)
  File "/homes/3/serai/.conda/envs/tensorflow_r1.0_gpu/lib/python3.6/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", line 787, in embedding_attention_decoder
    initial_state_attention=initial_state_attention)
  File "/homes/3/serai/.conda/envs/tensorflow_r1.0_gpu/lib/python3.6/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", line 686, in attention_decoder
    cell_output, state = cell(x, state)
  File "/homes/3/serai/.conda/envs/tensorflow_r1.0_gpu/lib/python3.6/site-packages/tensorflow/contrib/rnn/python/ops/core_rnn_cell_impl.py", line 796, in __call__
    % (len(self.state_size), state))
ValueError: Expected state to be a tuple of length 3, but received: Tensor("model_with_buckets/embedding_attention_seq2seq/rnn/gru_cell_4/add:0", shape=(?, 1024), dtype=float32)

@oxwsds Ändert sich Ihre Meinung auf der Grundlage der obigen vollständigen Spur?

@prashantserai Ich habe versucht zu dekodieren und es funktioniert gut. Ich füge einfach ein encoder_cell Argument zur Funktion tf.contrib.legacy_seq2seq.embedding_attention_seq2seq hinzu und erstelle in translate/seq2seq_model.py die Zelle und übergebe sie an die Funktion, die in der Funktion seq2seq_f aufgerufen wurde. Wie hast du deinen Code geändert?

@oxwsds @robmsylvester @ebrevdo
Ich habe endlich etwas, das jetzt funktioniert (ich meine, die Ergebnisse für mein Single-Layer-Netzwerk mit 256 Einheiten sind irgendwie entsetzlich, aber das liegt wahrscheinlich nur daran, dass das Netzwerk ultraleicht ist und ich die Parameter ÜBERHAUPT NICHT eingestellt habe).
Vielen Dank an alle...!!!!!

_Hier sind meine Gedanken am Ende:_

@oxwsds kommentiert , dass das Tutorial (in seiner aktuellen Form) ohne Änderungsbedarf funktioniert, wenn Tensorflow aus dem Zweig remotes/origin/r1.0 was TRUE kompiliert wird . Das Traurige war jedoch, dass die Version von Tensorflow, die ich hatte, für die Änderungen im Tensorflow-Code erforderlich waren, und die Version in remotes/origin/r1.0 beide identisch beschriftet waren.

Der Fix von @robmsylvester im Kommentar (unten kopiert) hat für meine Version von Tensorflow funktioniert, bei der das Tutorial nicht sofort einsatzbereit war (und sollte meiner Meinung nach auch für TF 1.1 funktionieren). Es ist etwas chaotisch zu implementieren, aber ich könnte es tun, was etwas aussagt :-P
Der Fehler in meinen letzten beiden Kommentaren davor war auf meinen Fehler zurückzuführen. Wie ein Dummy habe ich die Parameter der Ebenen und versteckten Einheiten nur während des Trainings angegeben, ich habe den Code verlassen, um während der Dekodierung Standardwerte zu verwenden. (Dieser Teil des Tutorials könnte etwas mehr Dummy-Beweis sein: https://www.tensorflow.org/tutorials/seq2seq#lets_run_it )

Hmmm. Eine Sache, die mir auffällt, ist in der referenzierten Legacy-seq2seq-Datei:

encoder_cell = copy.deepcopy (Zelle)

Diese Leitung scheint verwendet zu werden, da dieselbe Architektur sowohl auf der Codierer- als auch auf der Decodiererseite verwendet wird. Sie erstellen eine Kopie der Zelle und leiten dann das Zellenargument an die Einbettungsfunktion des Aufmerksamkeits-Decoders und dann an den Aufmerksamkeits-Decoder selbst weiter.

Was passiert, wenn Sie die Encoder-Zelle UND die Decoder-Zelle explizit in Ihrer seq2seq-Modelldatei erstellen und beide an die Legacy-Bibliotheksdatei weitergeben und die kleinen Anpassungen an den Funktionen und ihren Argumenten vornehmen?

Danke für die Rückmeldung! Anscheinend gibt es Unterschiede zwischen den TF
auf pypi und an diesem Tag? Gunhan, ist das möglich?

Am Montag, 10. April 2017 um 21:05 Uhr, prashantserai [email protected]
schrieb:

@oxwsds https://github.com/oxwsds @robmsylvester
https://github.com/robmsylvester @ebrevdo https://github.com/ebrevdo
Ich habe endlich etwas, das jetzt funktioniert (ich meine, Ergebnisse für meine Single
Layer 256 Unit Network sind irgendwie entsetzlich, aber das ist wahrscheinlich nur so
weil das Netzwerk ultraleicht ist und ich die Parameter ÜBERHAUPT NICHT eingestellt habe)

Hier ist mein Fazit:

@oxwsds https://github.com/oxwsds kommentieren , dass das Tutorial (in seiner Dateiaktuelle Form) funktioniert ohne Änderungsbedarf bei Tensorflowkompiliert aus dem Zweig remotes/origin/r1.0 war TRUE . Das traurige bisschen
Obwohl dies die Version von Tensorflow war, für die ich Änderungen hatte
innerhalb des Tensorflow-Codes benötigt wurden, und die Version in remotes/origin/r1.0
waren beide identisch beschriftet.

@robmsylvester https://github.com/robmsylvester 's Fix im Kommentar
(unten kopiert) HAT FUNKTIONIERT für meine Version von Tensorflow, wo das Tutorial
hat nicht sofort funktioniert (und sollte auch für TF 1.1 funktionieren, denke ich). es ist
Etwas chaotisch zu implementieren, aber ich könnte es tun, was etwas aussagt
:-P
Der Fehler in meinen letzten beiden Kommentaren davor war auf meinen Fehler zurückzuführen. Mögen
ein Dummy, ich habe nur die Parameter der Ebenen und versteckten Einheiten angegeben
Während des Trainings habe ich den Code verlassen, um beim Decodieren Standardwerte zu verwenden. (DiesTeil des Tutorials könnte etwas mehr Dummy-Beweis sein:https://www.tensorflow.org/tutorials/seq2seq#lets_run_ithttps://www.tensorflow.org/tutorials/seq2seq#lets_run_it )

Hmmm. Eine Sache, die mir auffällt, ist das referenzierte Legacy-seq2seq
Datei:

encoder_cell = copy.deepcopy (Zelle)

Diese Zeile scheint verwendet zu werden, da auf beiden dieselbe Architektur verwendet wird
Encoder- und Decoderseite. Sie machen eine Kopie der Zelle und geben sie dann weiter
cell-Argument zusammen mit der Aufmerksamkeits-Decoder-Einbettungsfunktion, dann zu
der Aufmerksamkeitsdecoder selbst.

Was passiert, wenn Sie explizit die Encoder-Zelle UND den Decoder erstellen?
cell in Ihrer seq2seq-Modelldatei und übergeben Sie beide an die Legacy-Bibliothek
Datei, die kleine Anpassungen an den Funktionen und ihren Argumenten vornimmt?

—
Sie erhalten dies, weil Sie erwähnt wurden.
Antworten Sie direkt auf diese E-Mail und zeigen Sie sie auf GitHub an
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-293143828 ,
oder den Thread stumm schalten
https://github.com/notifications/unsubscribe-auth/ABtimxvcfFnbWbpj7aUs3BUjwGEFj6p5ks5ruvvygaJpZM4MWl4f
.

Zur Information hatte ich dieses Problem beim Versuch, LSTM-Zellen zu stapeln:
Mein ursprünglicher Code war:

    lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_size, forget_bias=0.0, state_is_tuple=True)
    if is_training and keep_prob < 1:
      lstm_cell = tf.nn.rnn_cell.DropoutWrapper(
          lstm_cell, output_keep_prob=keep_prob)
    cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * num_layers, state_is_tuple=True)

Dann war das Erstellen des Modells mit dem folgenden Code in Ordnung, aber ich konnte die Variable nicht mit einem anderen Modell teilen. (Wenn Sie beispielsweise ein train_model und ein valid_model erstellen, die Tensoren gemeinsam nutzen sollen, schlägt dies fehl.)

    lstm_creator = lambda: tf.contrib.rnn.BasicLSTMCell(
                                        hidden_size, 
                                        forget_bias=0.0, state_is_tuple=True)
    if is_training and keep_prob < 1:
      cell_creator = lambda:tf.contrib.rnn.DropoutWrapper(
          lstm_creator(), output_keep_prob=keep_prob)
    else:
      cell_creator = lstm_creator

    cell = tf.contrib.rnn.MultiRNNCell([cell_creator() for _ in range(num_layers)], state_is_tuple=True)

Also habe ich schließlich lstm_creator als Funktion wie lstm_cell in tensorflow/models/tutorials/rnn/ptb/ptb_word_lm.py#L112 verwendet . Ich habe jetzt:

def lstm_cell():
      # With the latest TensorFlow source code (as of Mar 27, 2017),
      # the BasicLSTMCell will need a reuse parameter which is unfortunately not
      # defined in TensorFlow 1.0. To maintain backwards compatibility, we add
      # an argument check here:
      if 'reuse' in inspect.getargspec(
          tf.contrib.rnn.BasicLSTMCell.__init__).args:
        return tf.contrib.rnn.BasicLSTMCell(
            size, forget_bias=0.0, state_is_tuple=True,
            reuse=tf.get_variable_scope().reuse)
      else:
        return tf.contrib.rnn.BasicLSTMCell(
            size, forget_bias=0.0, state_is_tuple=True)
    attn_cell = lstm_cell

    lstm_creator = lstm_cell
    if is_training and keep_prob < 1:
      cell_creator = lambda:tf.contrib.rnn.DropoutWrapper(
          lstm_creator(), output_keep_prob=keep_prob)
    else:
      cell_creator = lstm_creator

    cell = tf.contrib.rnn.MultiRNNCell([cell_creator() for _ in range(num_layers)], state_is_tuple=True)

Es funktioniert jetzt voll

versucht, dieses Ding zum Laufen zu bringen, was zu demselben Fehler führt:

https://gist.github.com/danijar/c7ec9a30052127c7a1ad169eeb83f159#file -blog_tensorflow_sequence_classification-py-L38

Die Lösung von @pltrdy hat es für mich seltsamerweise nicht getan. Ich erhalte

ValueError: Variable rnn/multi_rnn_cell/cell_0/basic_lstm_cell/weights does not exist, or was not created with tf.get_variable(). Did you mean to set reuse=None in VarScope?

@aep hast du die Funktion von https://github.com/tensorflow/models/blob/master/tutorials/rnn/ptb/ptb_word_lm.py#L112 verwendet, die ich am Ende meines Beitrags erwähne (jetzt bearbeitet, um klarer zu sein )

cells=[]
for _ in range(15):
    cell = create_lstm_cell(config)
    cells.append(cell)
lsmt_layers = rnn.MultiRNNCell(cells)

es hat mein Problem gelöst

Dieses Problem konnte durch die Installation einer älteren Version von Tensorflow behoben werden:
pip install -Iv tensorflow==1.0

Ich habe den Fehler beim Ausführen des seq2seq-Tutorials erhalten

In Bezug auf das, was @ebrevdo gesagt hat, denke ich, dass die Lösung nicht darin besteht, den alten seq2seq-Code zu reparieren, sondern das Tutorial so zu aktualisieren, dass stattdessen das contrib.seq2seq -Paket verwendet wird, das aktiv gepflegt wird. Es ist ziemlich demoralisierend, wenn das erste Tensorflow-Programm, das Sie jemals ausführen, eine Reihe von Fehlern ausspuckt. Wenn ich diese Woche etwas Zeit habe, werde ich eine PN einreichen.

Wir arbeiten an einem neuen seq2seq-Tutorial. Wir hatten gehofft, bis Ende freizugeben
letzten Monat, verzögern sich aber. Es wird die neue API verwenden.

Am 1. Mai 2017 um 8:07 Uhr schrieb „Kyle Teague“ [email protected] :

In Bezug auf das, was @ebrevdo https://github.com/ebrevdo gesagt hat, denke ich
Die Lösung besteht nicht darin, den alten seq2seq-Code zu reparieren, sondern den zu aktualisieren
Tutorial, um stattdessen das Paket contrib.seq2seq zu verwenden, das aktiv ist
gepflegt. Es ist ziemlich demoralisierend, wenn man das erste Tensorflow-Programm bekommt
jemals ausgeführt spuckt eine Reihe von Fehlern aus. Wenn ich diese Woche etwas Zeit habe, werde ich es tun
PN einreichen.

—
Sie erhalten dies, weil Sie erwähnt wurden.
Antworten Sie direkt auf diese E-Mail und zeigen Sie sie auf GitHub an
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-298350307 ,
oder den Thread stumm schalten
https://github.com/notifications/unsubscribe-auth/ABtim587xZx9Gi4-yXmwccSum8_Trc1oks5r1fUogaJpZM4MWl4f
.

@ebrevdo Ich treffe auf den gleichen Fehler, wenn ich das sequence_to_sequence-Modell auf der tensorflow1.1-Website ausführe. Und ich habe versucht, den Parameter "Wiederverwendung" zu verwenden, bin aber gescheitert. Können Sie mir sagen, wann das neue seq2seq-Tutorial veröffentlicht wird?

Sieht zeitgleich wie tf 1.2 aus, da werden wir auf einiges neu setzen
Funktionen dieser Version.

Am 4. Mai 2017 um 21:16 Uhr schrieb „njuzrs“ [email protected] :

@ebrevdo https://github.com/ebrevdo Ich treffe beim Ausführen auf denselben Fehler
das sequence_to_sequence-Modell auf der tensorflow1.1-Website. Und ich habe es versucht
Parameter 'wiederverwenden' zu verwenden, aber fehlgeschlagen. Können Sie mir sagen, wann die neue seq2seq
Tutorial wird veröffentlicht?

—
Sie erhalten dies, weil Sie erwähnt wurden.
Antworten Sie direkt auf diese E-Mail und zeigen Sie sie auf GitHub an
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-299366774 ,
oder den Thread stumm schalten
https://github.com/notifications/unsubscribe-auth/ABtim8_kFTM7-SsXQAA-Ar0dfhHMGT0Zks5r2qKngaJpZM4MWl4f
.

@ebrevdo Ich stehe auch vor dem gleichen Problem und kann mit seq2seq nicht fortfahren. Es wäre sehr hilfreich, wenn Sie uns/mir einen voraussichtlichen Termin für ein neues Tutorial mitteilen könnten.
Vielen dank für Deine Hilfe.

Die Installation mit pip install tensorflow==1.0 (Tensorflow 1.0) funktioniert bei mir (Tutorial übersetzen).

Ich habe Version 1.1.0-rc2.

TF1.2 wird dieses Problem lösen? Bitte helfen Sie mir, das Modell weiter zu trainieren. TF 1.0 funktioniert, hat aber keine Devicewrapper-API für mehrere GPUs.

Habe das gleiche Problem mit Tensor Flow 1.1. Arbeite noch an einer Lösung

Ich habe mehrere Dinge ausprobiert, am Ende konnte ich Tensorflow 1.1 verwenden, musste aber diese Änderungen vornehmen: (basierend auf Tshzzz oben)

Entferne das:
multicell = rnn.MultiRNNCell([dropcell]*NLAYERS, state_is_tuple=False)

Und füge das hinzu:
Zellen=[]
für _ im Bereich (NLAYER):
cell = rnn.DropoutWrapper(tf.contrib.rnn.GRUCell(INTERNALSIZE), input_keep_prob=pkeep)
Zellen.anhängen (Zelle)
multicell = rnn.MultiRNNCell(cells, state_is_tuple=False)

@ebrevdo Herzlichen Glückwunsch, TF 1.2 wurde gerade veröffentlicht - wurde das neue Tutorial auch irgendwo veröffentlicht oder wird es bald veröffentlicht?

Danke

Wir planen eine Ankündigung, wenn es veröffentlicht wird. Daran zu arbeiten.

Am 19. Mai 2017 um 19:02 Uhr schrieb „prashantserai“ [email protected] :

@ebrevdo https://github.com/ebrevdo Herzlichen Glückwunsch, TF 1.2 ist gerade angekommen
released - wurde das neue Tutorial auch irgendwo veröffentlicht oder wird gerade veröffentlicht
bald veröffentlicht?

Danke

—
Sie erhalten dies, weil Sie erwähnt wurden.
Antworten Sie direkt auf diese E-Mail und zeigen Sie sie auf GitHub an
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-302844002 ,
oder den Thread stumm schalten
https://github.com/notifications/unsubscribe-auth/ABtim0RWDzNCXk-bIjKSyHLvgFxUvq2lks5r7km7gaJpZM4MWl4f
.

Für alle, die tensorflow-gpu==1.1.0 verwenden und diesen Fehler erhalten, wird der Wechsel zu 1.0.0 über pip install tensorflow-gpu==1.0.0 das Problem nicht beheben, zumindest hat es bei mir nicht funktioniert.

Ich bin sowohl auf Mac als auch auf Ubuntu auf dieses Problem gestoßen, und das Kompilieren aus der Quelle hat beide Male funktioniert. So:
Pip-Installation https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.0.0-cp34-cp34m-linux_x86_64.whl

@ajaanbaahu Ich warte immer noch auf das neue seq2seq-Tutorial von tf1.2.

Bei mir hat es mit pip install tensorflow==1.0 funktioniert.

Für tf r1.2 wurde ein Deepcopy-Fehler angezeigt. Wie in der Reihenfolge aufgeführt , um Modellfehler Nr. 1050 zu sequenzieren

Als Neuling erhebe ich teilweise meine Meinung.
Der folgende Code wird diesen ähnlichen Fehler verursachen:
(Teil meines Codes)

lstm_cell = self.LSTMCell(self.num_hidden)
lstm_entity = tf.contrib.rnn.DropoutWrapper(lstm_cell, output_keep_prob=0.5)
layer = tf.contrib.rnn.MultiRNNCell([lstm_entity] * self.num_layer)
__, _ = tf.nn.dynamic_rnn(layer, self.data, dtype=tf.float64)

Der Fehlerspeicher wie folgt:

Traceback (most recent call last):
  File "IntentNet.py", line 71, in <module>
    net = Net(data, target, 5, 1)
  File "IntentNet.py", line 45, in __init__
    __, _ = tf.nn.dynamic_rnn(layer, self.data, dtype=tf.float64)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/ops/rnn.py", line 553, in dynamic_rnn
    dtype=dtype)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/ops/rnn.py", line 720, in _dynamic_rnn_loop
    swap_memory=swap_memory)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/ops/control_flow_ops.py", line 2623, in while_loop
    result = context.BuildLoop(cond, body, loop_vars, shape_invariants)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/ops/control_flow_ops.py", line 2456, in BuildLoop
    pred, body, original_loop_vars, loop_vars, shape_invariants)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/ops/control_flow_ops.py", line 2406, in _BuildLoop
    body_result = body(*packed_vars_for_body)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/ops/rnn.py", line 705, in _time_step
    (output, new_state) = call_cell()
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/python/ops/rnn.py", line 691, in <lambda>
    call_cell = lambda: cell(input_t, state)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/contrib/rnn/python/ops/core_rnn_cell_impl.py", line 953, in __call__
    cur_inp, new_state = cell(cur_inp, cur_state)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/contrib/rnn/python/ops/core_rnn_cell_impl.py", line 713, in __call__
    output, new_state = self._cell(inputs, state, scope)
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/contrib/rnn/python/ops/core_rnn_cell_impl.py", line 235, in __call__
    with _checked_scope(self, scope or "basic_lstm_cell", reuse=self._reuse):
  File "/usr/lib/python2.7/contextlib.py", line 17, in __enter__
    return self.gen.next()
  File "/usr/local/lib/python2.7/dist-packages/tensorflow/contrib/rnn/python/ops/core_rnn_cell_impl.py", line 77, in _checked_scope
    type(cell).__name__))
ValueError: Attempt to reuse RNNCell <tensorflow.contrib.rnn.python.ops.core_rnn_cell_impl.BasicLSTMCell object at 0x7fe4fc7bd150> with a different variable scope than its first use.  First use of cell was with scope 'rnn/multi_rnn_cell/cell_0/basic_lstm_cell', this attempt is with scope 'rnn/multi_rnn_cell/cell_1/basic_lstm_cell'.  Please create a new instance of the cell if you would like it to use a different set of weights.  If before you were using: MultiRNNCell([BasicLSTMCell(...)] * num_layers), change to: MultiRNNCell([BasicLSTMCell(...) for _ in range(num_layers)]).  If before you were using the same cell instance as both the forward and reverse cell of a bidirectional RNN, simply create two instances (one for forward, one for reverse).  In May 2017, we will start transitioning this cell's behavior to use existing stored weights, if any, when it is called with scope=None (which can lead to silent model degradation, so this error will remain until then.)

Aber nachdem ich die Revision gemacht habe, kann es funktionieren.

"""
lstm_cell = self.LSTMCell(self.num_hidden)
lstm_entity = tf.contrib.rnn.DropoutWrapper(lstm_cell, output_keep_prob=0.5)
layer = tf.contrib.rnn.MultiRNNCell([lstm_entity] * self.num_layer)
"""
layer = []
for i in range(self.num_layer):
    lstm_cell = self.LSTMCell(self.num_hidden)
    lstm_entity = tf.contrib.rnn.DropoutWrapper(lstm_cell, output_keep_prob=0.5)
    layer.append(lstm_entity)
layer = tf.contrib.rnn.MultiRNNCell(layer)
__, _ = tf.nn.dynamic_rnn(layer, self.data, dtype=tf.float64)

Keine dieser Problemumgehungen hat bei mir mit Tensorflow 1.1 funktioniert

Ich verwende das seq2seq -Modell mit MultiRNNCell -Zellen.

Ich musste zu 1.0.1 zurückkehren: pip3 install tensorflow==1.0

Hat jemand diese Probleme bei der Arbeit mit legacy_seq2seq.rnn_decoder()?

@oxwsds Wie Sie sagten, ändere ich die Eingangsargumentzelle von tf.contrib.legacy_seq2seq.embedding_attention_seq2seq in zwei verschiedene Zellen {encoder_cells, decoder_cells}. Schließlich bekomme ich das seq2seq-Modell zum Laufen. Nach 73200 Setps bekomme ich Perplexity 5.54.
Dann führe ich den Dekodierungsteil aus,

Wer ist der Präsident der Vereinigten Staaten?
Qui est le président des États-Unis?

Problem gelöst. Danke.

@doncat99
Es scheint, dass copy.deepcopy(cell) in seq2seq.py keine Wirkung zeigt.
Also ändere ich den zugehörigen Teil in seq2seq_model.py in

if num_layers > 1:
      cell_enc = tf.contrib.rnn.MultiRNNCell([single_cell() for _ in range(num_layers)])
      cell_dec = tf.contrib.rnn.MultiRNNCell([single_cell() for _ in range(num_layers)])

    # The seq2seq function: we use embedding for the input and attention.
    def seq2seq_f(encoder_inputs, decoder_inputs, do_decode):
      return seq2seq.embedding_attention_seq2seq(
          encoder_inputs,
          decoder_inputs,
          cell_enc,
          cell_dec,
          num_encoder_symbols=source_vocab_size,
          num_decoder_symbols=target_vocab_size,
          embedding_size=size,
          output_projection=output_projection,
          feed_previous=do_decode,
          dtype=dtype)

@supermeatboy82 , könntest du deinen Code teilen?

Das Upgrade auf Tensorflow 1.2.0 und das Generieren der Zellen in einer Schleife anstelle der Listenmultiplikation hat dies für mich behoben.

Habe den Fehler mit TF1.2 beim Ausführen von translate.py, Details:
Bezeichnung: GeForce GTX 1080 Ti
Major: 6 Minor: 1 MemoryClockRate (GHz) 1,582
pciBusID 0000:02:00.0
Gesamtspeicher: 10,91 GiB
Freier Speicher: 10,76 GiB
2017-06-22 09:15:04.485252: I tensorflow/core/common_runtime/gpu/gpu_device.cc:961] DMA: 0
2017-06-22 09:15:04.485256: I tensorflow/core/common_runtime/gpu/gpu_device.cc:971] 0: J
2017-06-22 09:15:04.485265: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1030] Erstellen von TensorFlow-Gerät (/gpu:0) -> (Gerät: 0, Name: GeForce GTX 1080 Ti, pci Bus-ID: 0000:02:00.0)
Erstellen von 3 Ebenen mit 1024 Einheiten.
Traceback (letzter Aufruf zuletzt):
Datei „translate.py“, Zeile 322, in
tf.app.run()
Datei „/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/python/platform/app.py“, Zeile 48, in Ausführung
_sys.exit(main(_sys.argv[:1] + flags_passthrough))
Datei „translate.py“, Zeile 319, in main
Zug()
Datei "translate.py", Zeile 178, im Zug
model = create_model(sess, False)
Datei „translate.py“, Zeile 136, in create_model
dtyp=dtyp)
Datei "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", Zeile 179, in __init__
softmax_loss_function=softmax_loss_function)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py“, Zeile 1206, in model_with_buckets
decoder_inputs[:bucket[1]])
Datei "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", Zeile 178, in
Lambda x, y: seq2seq_f(x, y, False),
Datei „/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py“, Zeile 142, in seq2seq_f
dtyp=dtyp)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py“, Zeile 848, in embedding_attention_seq2seq
encoder_cell = copy.deepcopy (Zelle)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 174, in Deepcopy
y = Kopierer (Memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/python/layers/base.py“, Zeile 476, in __deepcopy__
setattr(Ergebnis, k, copy.deepcopy(v, Memo))
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 163, in Deepcopy
y = Kopierer(x, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 230, in _deepcopy_list
y.append(deepcopy(a, memo))
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 190, in Deepcopy
y = _reconstruct(x, rv, 1, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 334, in _reconstruct
state = deepcopy(state, memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 163, in Deepcopy
y = Kopierer(x, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 257, in _deepcopy_dict
y[deepcopy(Schlüssel, Memo)] = deepcopy(Wert, Memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 190, in Deepcopy
y = _reconstruct(x, rv, 1, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 334, in _reconstruct
state = deepcopy(state, memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 163, in Deepcopy
y = Kopierer(x, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 257, in _deepcopy_dict
y[deepcopy(Schlüssel, Memo)] = deepcopy(Wert, Memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 190, in Deepcopy
y = _reconstruct(x, rv, 1, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 334, in _reconstruct
state = deepcopy(state, memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 163, in Deepcopy
y = Kopierer(x, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 257, in _deepcopy_dict
y[deepcopy(Schlüssel, Memo)] = deepcopy(Wert, Memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 190, in Deepcopy
y = _reconstruct(x, rv, 1, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 334, in _reconstruct
state = deepcopy(state, memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 163, in Deepcopy
y = Kopierer(x, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 257, in _deepcopy_dict
y[deepcopy(Schlüssel, Memo)] = deepcopy(Wert, Memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 163, in Deepcopy
y = Kopierer(x, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 257, in _deepcopy_dict
y[deepcopy(Schlüssel, Memo)] = deepcopy(Wert, Memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 163, in Deepcopy
y = Kopierer(x, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 230, in _deepcopy_list
y.append(deepcopy(a, memo))
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 190, in Deepcopy
y = _reconstruct(x, rv, 1, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 334, in _reconstruct
state = deepcopy(state, memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 163, in Deepcopy
y = Kopierer(x, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 257, in _deepcopy_dict
y[deepcopy(Schlüssel, Memo)] = deepcopy(Wert, Memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 190, in Deepcopy
y = _reconstruct(x, rv, 1, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 334, in _reconstruct
state = deepcopy(state, memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 163, in Deepcopy
y = Kopierer(x, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 257, in _deepcopy_dict
y[deepcopy(Schlüssel, Memo)] = deepcopy(Wert, Memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 190, in Deepcopy
y = _reconstruct(x, rv, 1, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 334, in _reconstruct
state = deepcopy(state, memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 163, in Deepcopy
y = Kopierer(x, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 257, in _deepcopy_dict
y[deepcopy(Schlüssel, Memo)] = deepcopy(Wert, Memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 163, in Deepcopy
y = Kopierer(x, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 230, in _deepcopy_list
y.append(deepcopy(a, memo))
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 163, in Deepcopy
y = Kopierer(x, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 237, in _deepcopy_tuple
y.append(deepcopy(a, memo))
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 163, in Deepcopy
y = Kopierer(x, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 257, in _deepcopy_dict
y[deepcopy(Schlüssel, Memo)] = deepcopy(Wert, Memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 190, in Deepcopy
y = _reconstruct(x, rv, 1, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 334, in _reconstruct
state = deepcopy(state, memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 163, in Deepcopy
y = Kopierer(x, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 257, in _deepcopy_dict
y[deepcopy(Schlüssel, Memo)] = deepcopy(Wert, Memo)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 190, in Deepcopy
y = _reconstruct(x, rv, 1, Notiz)
Datei „/home/lscm/opt/anaconda2/lib/python2.7/copy.py“, Zeile 343, in _reconstruct
y.__dict__.update(Zustand)
AttributeError: 'NoneType'-Objekt hat kein Attribut 'update'

Ich bin auch auf den Fehler gestoßen, der durch copy.deepcopy(cell) in embedding_attention_seq2seq() verursacht wurde, wenn self_test() im Übersetzungsmodell im Tutorial ausgeführt wurde.
Ich habe versucht, die Codes in seq2seq_f() in Seq2SeqModel wie folgt zu ändern:

    def seq2seq_f(encoder_inputs, decoder_inputs, do_decode=False):
        tmp_cell = copy.deepcopy(cell) #new
        return tf.contrib.legacy_seq2seq.embedding_attention_seq2seq(
            encoder_inputs,
            decoder_inputs,
            tmp_cell, #new
            num_encoder_symbols=source_vocab_size,
            num_decoder_symbols=target_vocab_size,
            embedding_size=size,
            output_projection=output_projection,
            feed_previous=do_decode,
            dtype=dtype)

Dann liegt jetzt kein Fehler vor.
ABER als Neuling weiß ich nicht, ob die Codes hier wie vorher funktionieren und es scheint, dass die Änderungen das Modell langsamer laufen lassen.

Ich möchte allen mitteilen, dass ich Tensorflow auf 1.0.0 (Tensorflow-GPU) heruntergestuft habe und es bei mir funktioniert. Die Modelle funktionieren wie erwartet. Ich gehe davon aus, dass die CPU-Version 1.0.0 wie erwartet funktionieren sollte? Oder?.
Danke :)

Hallo Leute, ich weiß nicht, ob es Sie noch interessiert, aber ich habe festgestellt, dass das Problem mit dem Vorgang des Kopierens der Zelle zusammenhängt, die als Parameter an die Funktion embedding_attention_seq2seq übergeben wird. Dies liegt daran, dass dieselbe Zellendefinition sowohl für den Codierer als auch für den Decodierer verwendet wird. Ich denke, das Tutorial ist veraltet, da es ein seq2seq-Modell mit Bucketing im Gegensatz zu einem dynamischen seq2seq verwendet. Aber ich füge eine modifizierte Funktion ein, die funktioniert. Die Funktion wird in der Datei tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py aktualisiert.

Danke,
Fabio

```!python
def embedding_attention_seq2seq(encoder_inputs,
Decoder_Eingänge,
enc_cell,
dec_cell,
num_encoder_symbols,
num_decoder_symbols,
Einbettungsgröße,
num_heads=1,
output_projection=Keine,
feed_ previous=Falsch,
dtype=Keine,
Geltungsbereich=Keine,
initial_state_attention=False):
"""Sequenz-zu-Sequenz-Modell mit Aufmerksamkeit einbetten.

Dieses Modell bettet zunächst encoder_inputs durch eine neu erstellte Einbettung (von shape
[Anzahl_Encoder_Symbole x Eingabe_Größe]). Dann führt es ein RNN zum Kodieren aus
eingebettete encoder_inputs in einen Zustandsvektor. Es hält die Ausgänge davon
RNN bei jedem Schritt, um später für Aufmerksamkeit zu sorgen. Als nächstes bettet es decoder_inputs ein
durch eine weitere neu erstellte Einbettung (der Form [num_decoder_symbols x
Eingabegröße]). Dann läuft es Achtung Decoder, mit dem letzten initialisiert
Encoder-Zustand, auf eingebetteten decoder_inputs und der Betreuung von Encoder-Ausgängen.

Warnung: Wenn output_projection None ist, die Größe der Aufmerksamkeitsvektoren
und Variablen werden proportional zu num_decoder_symbols gemacht, können groß sein.

Argumente:
encoder_inputs: Eine Liste von 1D-int32-Tensoren der Form [batch_size].
decoder_inputs: Eine Liste von 1D-int32-Tensoren der Form [batch_size].
Zelle: tf.nn.rnn_cell.RNNCell definiert die Zellfunktion und -größe.
num_encoder_symbols: Ganzzahl; Anzahl Symbole auf der Geberseite.
num_decoder_symbols: Ganzzahl; Anzahl der Symbole auf der Decoderseite.
embedding_size: Ganzzahl, die Länge des Einbettungsvektors für jedes Symbol.
num_heads: Anzahl der Attention Heads, die von Attention_States gelesen haben.
output_projection: Keine oder ein Paar (W, B) von Ausgabeprojektionsgewichten und
Vorurteile; W hat die Form [output_size x num_decoder_symbols] und B hat
Form [num_decoder_symbols]; falls angegeben und feed_ previous=True, jeweils
Eingespeiste vorherige Ausgabe wird zunächst mit W multipliziert und B addiert.
feed_ previous: Boolescher oder skalarer Boolescher Tensor; wenn wahr, nur die erste
von decoder_inputs verwendet werden (das "GO"-Symbol) und alle anderen Decoder
Eingaben werden von vorherigen Ausgaben genommen (wie in embedding_rnn_decoder).
Falls falsch, werden decoder_inputs wie gegeben verwendet (der Standard-Decoder-Fall).
dtype: Der dtype des anfänglichen RNN-Zustands (Standard: tf.float32).
scope: VariableScope für den erstellten Teilgraphen; standardmäßig auf
"embedding_attention_seq2seq".
initial_state_attention: Wenn False (Standard), sind anfängliche Aufmerksamkeiten null.
Wenn True, initialisieren Sie die Aufmerksamkeiten aus dem Anfangszustand und der Aufmerksamkeit
Zustände.

Kehrt zurück:
Ein Tupel des Formulars (Ausgänge, Zustand), wobei:
Ausgänge: Eine Liste der gleichen Länge wie decoder_inputs von 2D-Tensoren mit
Form [batch_size x num_decoder_symbols] mit den generierten
Ausgänge.
Zustand: Der Zustand jeder Decoderzelle im letzten Zeitschritt.
Es ist ein 2D-Tensor der Form [batch_size x cell.state_size].
"""
mit variable_scope.variable_scope(
scope oder "embedding_attention_seq2seq", dtype=dtype) als Scope:
dtype = Bereich.dtype
# Encoder.

encoder_cell = enc_cell

encoder_cell = core_rnn_cell.EmbeddingWrapper(
    encoder_cell,
    embedding_classes=num_encoder_symbols,
    embedding_size=embedding_size)
encoder_outputs, encoder_state = rnn.static_rnn(
    encoder_cell, encoder_inputs, dtype=dtype)

# First calculate a concatenation of encoder outputs to put attention on.
top_states = [
    array_ops.reshape(e, [-1, 1, encoder_cell.output_size]) for e in encoder_outputs
]
attention_states = array_ops.concat(top_states, 1)

# Decoder.
output_size = None
if output_projection is None:
  dec_cell = core_rnn_cell.OutputProjectionWrapper(dec_cell, num_decoder_symbols)
  output_size = num_decoder_symbols

if isinstance(feed_previous, bool):
  return embedding_attention_decoder(
      decoder_inputs,
      encoder_state,
      attention_states,
      dec_cell,
      num_decoder_symbols,
      embedding_size,
      num_heads=num_heads,
      output_size=output_size,
      output_projection=output_projection,
      feed_previous=feed_previous,
      initial_state_attention=initial_state_attention)

# If feed_previous is a Tensor, we construct 2 graphs and use cond.
def decoder(feed_previous_bool):
  reuse = None if feed_previous_bool else True
  with variable_scope.variable_scope(
      variable_scope.get_variable_scope(), reuse=reuse):
    outputs, state = embedding_attention_decoder(
        decoder_inputs,
        encoder_state,
        attention_states,
        dec_cell,
        num_decoder_symbols,
        embedding_size,
        num_heads=num_heads,
        output_size=output_size,
        output_projection=output_projection,
        feed_previous=feed_previous_bool,
        update_embedding_for_previous=False,
        initial_state_attention=initial_state_attention)
    state_list = [state]
    if nest.is_sequence(state):
      state_list = nest.flatten(state)
    return outputs + state_list

outputs_and_state = control_flow_ops.cond(feed_previous,
                                          lambda: decoder(True),
                                          lambda: decoder(False))
outputs_len = len(decoder_inputs)  # Outputs length same as decoder inputs.
state_list = outputs_and_state[outputs_len:]
state = state_list[0]
if nest.is_sequence(encoder_state):
  state = nest.pack_sequence_as(
      structure=encoder_state, flat_sequence=state_list)
return outputs_and_state[:outputs_len], state

```

@fabiofumarola Danke für die Funktion. Sieht wirklich hilfreich aus. Ich habe auch gesehen, dass das Tutorial veraltet ist. Ich warte immer noch auf eine offizielle Tutorial-Veröffentlichung. Sieht so aus, als hätten Sie die neue API verwendet. Haben Sie einen Code, der nachgeschlagen werden kann, um mit dem Codieren auf der neuen API zu beginnen?
Jede Hilfe wird sehr geschätzt. Vielen Dank noch mal :)

@syw2014 Hast du dein Problem behoben?

@w268wang noch nicht, warte noch auf andere Lösungen, aber Kommentare von @Miopas können es versuchen, und ich versuche die Lösung von @fabiofumarola

da steht TypeError: embedding_attention_seq2seq() missing 1 required positional argument: 'dec_cell'
nach der Verwendung des Updates, das @fabiofumarola gepostet hat. Könnt ihr mir bitte helfen?

Ja, denn das von mir vorgeschlagene Update erfordert, dass Sie das ändern
embedding_attention_seq2seq-Funktion. Wenn du in die Quelldatei gehst
Tensorflow-Release können Sie die Methodendefinition selbst ändern.

Am Sonntag, 2. Juli 2017 um 18:15 Uhr, sachinh35 [email protected] trote

es sagt TypeError: embedding_attention_seq2seq() fehlt 1 erforderlich
Positionsargument: 'dec_cell'

—
Sie erhalten dies, weil Sie erwähnt wurden.
Antworten Sie direkt auf diese E-Mail und zeigen Sie sie auf GitHub an
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312500996 ,
oder den Thread stumm schalten
https://github.com/notifications/unsubscribe-auth/ABepUEc3W8m5CVDQGnCLu4dcJVFwwLDZks5sJ8IOgaJpZM4MWl4f
.

>

Gesendet von Gmail Mobile

Ja, ich habe das gleiche getan. Ich habe die Funktion in der Datei seq2seq.py in der Tensorflow-Version geändert. Ich bekomme immer noch den gleichen Fehler. Gibt es ein weiteres Argument für die Funktion?

Ja, jetzt müssen Sie in Ihrem Code rnn_cells angeben. Eine für den Encoder
und eine für den Decoder.

Am Sonntag, 2. Juli 2017 um 20:54 Uhr schrieb fabio fumarola [email protected] :

ja

Am Sonntag, den 2. Juli 2017 um 18:50 Uhr schrieb sachinh35 [email protected] :

Ja, ich habe das gleiche getan. Ich habe die Funktion in der Datei seq2seq.py in geändert
die Tensorflow-Freigabe. Ich bekomme immer noch den gleichen Fehler. Ist dort eines
mehr Argument für die Funktion?

—
Sie erhalten dies, weil Sie erwähnt wurden.
Antworten Sie direkt auf diese E-Mail und zeigen Sie sie auf GitHub an
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312503106 ,
oder den Thread stumm schalten
https://github.com/notifications/unsubscribe-auth/ABepUOXTQC_mzLuhcwW0iZRVkLmmr8yIks5sJ8pugaJpZM4MWl4f
.

>

Gesendet von Gmail Mobile

Ich bin ganz neu dabei. Vielleicht ist dies eine ziemlich grundlegende Frage, aber könnten Sie sagen, welches Argument als Decoderzelle in diesem Code übergeben werden soll? Ich versuche, die seq2seq wie im Tensorflow-Tutorial gezeigt mit einem eigenen Datensatz zu entwickeln.

`
aus __future__ import absolute_import
von __future__ Importabteilung
aus __future__ import print_function

willkürlich importieren

importiere numpy als np
from six.moves import xrange # pylint: disable=redefined-builtin
Tensorflow als tf importieren

importiere data_utils

Klasse Seq2SeqModel(Objekt):
def __init__(selbst,
source_vocab_size,
target_vocab_size,
Eimer,
Größe,
Anzahl_Ebenen,
max_gradient_norm,
Stapelgröße,
Lernrate,
learning_rate_decay_factor,
use_lstm=Falsch,
num_samples=512,
forward_only=Falsch,
dtype=tf.float32):

self.source_vocab_size = source_vocab_size
self.target_vocab_size = target_vocab_size
self.buckets = buckets
self.batch_size = batch_size
self.learning_rate = tf.Variable(
    float(learning_rate), trainable=False, dtype=dtype)
self.learning_rate_decay_op = self.learning_rate.assign(
    self.learning_rate * learning_rate_decay_factor)
self.global_step = tf.Variable(0, trainable=False)


output_projection = None
softmax_loss_function = None

if num_samples > 0 and num_samples < self.target_vocab_size:
  w_t = tf.get_variable("proj_w", [self.target_vocab_size, size], dtype=dtype)
  w = tf.transpose(w_t)
  b = tf.get_variable("proj_b", [self.target_vocab_size], dtype=dtype)
  output_projection = (w, b)

  def sampled_loss(labels, inputs):
    labels = tf.reshape(labels, [-1, 1])

    local_w_t = tf.cast(w_t, tf.float32)
    local_b = tf.cast(b, tf.float32)
    local_inputs = tf.cast(inputs, tf.float32)
    return tf.cast(
        tf.nn.sampled_softmax_loss(local_w_t, local_b, local_inputs, labels,
                                   num_samples, self.target_vocab_size),
        dtype)
  softmax_loss_function = sampled_loss


def single_cell():
  return tf.nn.rnn_cell.GRUCell(size)
if use_lstm:
  def single_cell():
    return tf.nn.rnn_cell.BasicLSTMCell(size)
cell = single_cell()
if num_layers > 1:
  cell = tf.nn.rnn_cell.MultiRNNCell([single_cell() for _ in range(num_layers)])


def seq2seq_f(encoder_inputs, decoder_inputs, do_decode):
  return tf.contrib.legacy_seq2seq.embedding_attention_seq2seq(
      encoder_inputs,
      decoder_inputs,
      cell,
      num_encoder_symbols=source_vocab_size,
      num_decoder_symbols=target_vocab_size,
      embedding_size=size,
      output_projection=output_projection,
      feed_previous=do_decode,
      dtype=dtype)


self.encoder_inputs = []
self.decoder_inputs = []
self.target_weights = []
for i in xrange(buckets[-1][0]):  # Last bucket is the biggest one.
  self.encoder_inputs.append(tf.placeholder(tf.int32, shape=[None],
                                            name="encoder{0}".format(i)))
for i in xrange(buckets[-1][1] + 1):
  self.decoder_inputs.append(tf.placeholder(tf.int32, shape=[None],
                                            name="decoder{0}".format(i)))
  self.target_weights.append(tf.placeholder(dtype, shape=[None],
                                            name="weight{0}".format(i)))

# Our targets are decoder inputs shifted by one.
targets = [self.decoder_inputs[i + 1]
           for i in xrange(len(self.decoder_inputs) - 1)]

# Training outputs and losses.
if forward_only:
  self.outputs, self.losses = tf.contrib.legacy_seq2seq.model_with_buckets(
      self.encoder_inputs, self.decoder_inputs, targets,
      self.target_weights, buckets, lambda x, y: seq2seq_f(x, y, True),
      softmax_loss_function=softmax_loss_function)
  # If we use output projection, we need to project outputs for decoding.
  if output_projection is not None:
    for b in xrange(len(buckets)):
      self.outputs[b] = [
          tf.matmul(output, output_projection[0]) + output_projection[1]
          for output in self.outputs[b]
      ]
else:
  self.outputs, self.losses = tf.contrib.legacy_seq2seq.model_with_buckets(
      self.encoder_inputs, self.decoder_inputs, targets,
      self.target_weights, buckets,
      lambda x, y: seq2seq_f(x, y, False),
      softmax_loss_function=softmax_loss_function)

# Gradients and SGD update operation for training the model.
params = tf.trainable_variables()
if not forward_only:
  self.gradient_norms = []
  self.updates = []
  opt = tf.train.GradientDescentOptimizer(self.learning_rate)
  for b in xrange(len(buckets)):
    gradients = tf.gradients(self.losses[b], params)
    clipped_gradients, norm = tf.clip_by_global_norm(gradients,
                                                     max_gradient_norm)
    self.gradient_norms.append(norm)
    self.updates.append(opt.apply_gradients(
        zip(clipped_gradients, params), global_step=self.global_step))

self.saver = tf.train.Saver(tf.global_variables())

def step(self, session, encoder_inputs, decoder_inputs, target_weights,
Bucket_id, forward_only):

# Check if the sizes match.
encoder_size, decoder_size = self.buckets[bucket_id]
if len(encoder_inputs) != encoder_size:
  raise ValueError("Encoder length must be equal to the one in bucket,"
                   " %d != %d." % (len(encoder_inputs), encoder_size))
if len(decoder_inputs) != decoder_size:
  raise ValueError("Decoder length must be equal to the one in bucket,"
                   " %d != %d." % (len(decoder_inputs), decoder_size))
if len(target_weights) != decoder_size:
  raise ValueError("Weights length must be equal to the one in bucket,"
                   " %d != %d." % (len(target_weights), decoder_size))

# Input feed: encoder inputs, decoder inputs, target_weights, as provided.
input_feed = {}
for l in xrange(encoder_size):
  input_feed[self.encoder_inputs[l].name] = encoder_inputs[l]
for l in xrange(decoder_size):
  input_feed[self.decoder_inputs[l].name] = decoder_inputs[l]
  input_feed[self.target_weights[l].name] = target_weights[l]

# Since our targets are decoder inputs shifted by one, we need one more.
last_target = self.decoder_inputs[decoder_size].name
input_feed[last_target] = np.zeros([self.batch_size], dtype=np.int32)

# Output feed: depends on whether we do a backward step or not.
if not forward_only:
  output_feed = [self.updates[bucket_id],  # Update Op that does SGD.
                 self.gradient_norms[bucket_id],  # Gradient norm.
                 self.losses[bucket_id]]  # Loss for this batch.
else:
  output_feed = [self.losses[bucket_id]]  # Loss for this batch.
  for l in xrange(decoder_size):  # Output logits.
    output_feed.append(self.outputs[bucket_id][l])

outputs = session.run(output_feed, input_feed)
if not forward_only:
  return outputs[1], outputs[2], None  # Gradient norm, loss, no outputs.
else:
  return None, outputs[0], outputs[1:]  # No gradient norm, loss, outputs.

def get_batch(selbst, Daten, Bucket_id):

encoder_size, decoder_size = self.buckets[bucket_id]
encoder_inputs, decoder_inputs = [], []

# Get a random batch of encoder and decoder inputs from data,
# pad them if needed, reverse encoder inputs and add GO to decoder.
for _ in xrange(self.batch_size):
  encoder_input, decoder_input = random.choice(data[bucket_id])

  # Encoder inputs are padded and then reversed.
  encoder_pad = [data_utils.PAD_ID] * (encoder_size - len(encoder_input))
  encoder_inputs.append(list(reversed(encoder_input + encoder_pad)))

  # Decoder inputs get an extra "GO" symbol, and are padded then.
  decoder_pad_size = decoder_size - len(decoder_input) - 1
  decoder_inputs.append([data_utils.GO_ID] + decoder_input +
                        [data_utils.PAD_ID] * decoder_pad_size)

# Now we create batch-major vectors from the data selected above.
batch_encoder_inputs, batch_decoder_inputs, batch_weights = [], [], []

# Batch encoder inputs are just re-indexed encoder_inputs.
for length_idx in xrange(encoder_size):
  batch_encoder_inputs.append(
      np.array([encoder_inputs[batch_idx][length_idx]
                for batch_idx in xrange(self.batch_size)], dtype=np.int32))

# Batch decoder inputs are re-indexed decoder_inputs, we create weights.
for length_idx in xrange(decoder_size):
  batch_decoder_inputs.append(
      np.array([decoder_inputs[batch_idx][length_idx]
                for batch_idx in xrange(self.batch_size)], dtype=np.int32))

  # Create target_weights to be 0 for targets that are padding.
  batch_weight = np.ones(self.batch_size, dtype=np.float32)
  for batch_idx in xrange(self.batch_size):
    # We set weight to 0 if the corresponding target is a PAD symbol.
    # The corresponding target is decoder_input shifted by 1 forward.
    if length_idx < decoder_size - 1:
      target = decoder_inputs[batch_idx][length_idx + 1]
    if length_idx == decoder_size - 1 or target == data_utils.PAD_ID:
      batch_weight[batch_idx] = 0.0
  batch_weights.append(batch_weight)
return batch_encoder_inputs, batch_decoder_inputs, batch_weights`

Dies ist eine gute Frage für den Stapelüberlauf.

Am 3. Juli 2017 um 8:46 Uhr schrieb "sachinh35" [email protected] :

Ich bin ganz neu dabei. Vielleicht ist dies eine ziemlich grundlegende Frage, aber könnten Sie
Sagen Sie, welches Argument als Decoderzelle in diesem Code übergeben werden soll? Ich bin
versuchen, seq2seq wie im Tensorflow-Tutorial gezeigt mit own zu entwickeln
Datensatz.
`# Copyright 2015 Die TensorFlow-Autoren. Alle Rechte vorbehalten.
Lizenziert unter der Apache-Lizenz, Version 2.0 (die „Lizenz“); Sie können
Verwenden Sie diese Datei nur in Übereinstimmung mit der Lizenz. Sie können eine erhalten
Kopie der Lizenz unter http://www.apache.org/licenses/LICENSE-2.0 Es sei denn
nach geltendem Recht vorgeschrieben oder schriftlich vereinbart, vertriebene Software
unter der Lizenz wird „WIE BESEHEN“ UND OHNE GEWÄHRLEISTUNG vertrieben
ODER BEDINGUNGEN JEGLICHER ART, weder ausdrücklich noch stillschweigend. Siehe die Lizenz für
die spezifische Sprache, die die Berechtigungen und Beschränkungen unter den regelt

Lizenz. =============================================== ==========

"""Sequenz-zu-Sequenz-Modell mit Aufmerksamkeitsmechanismus."""

aus zukünftigem Import absolute_import
aus der künftigen Importabteilung
aus dem zukünftigen Import von print_function

willkürlich importieren

importiere numpy als np
from six.moves import xrange # pylint: disable=redefined-builtin
Tensorflow als tf importieren

importiere data_utils

Klasse Seq2SeqModel(Objekt):
"""Sequence-to-Sequence-Modell mit Aufmerksamkeit und für mehrere Buckets.

Diese Klasse implementiert ein mehrschichtiges rekurrentes neuronales Netzwerk als Encoder,
und ein aufmerksamkeitsbasierter Decoder. Dies ist das gleiche wie das in beschriebene Modell
dieses Papier: http://arxiv.org/abs/1412.7449 - bitte suchen Sie dort nach
Einzelheiten,
oder in die seq2seq-Bibliothek für die vollständige Modellimplementierung.
Diese Klasse ermöglicht auch die Verwendung von GRU-Zellen zusätzlich zu LSTM-Zellen und
abgetastetes Softmax, um große Ausgabevokabulargrößen zu verarbeiten. Eine Einschicht
Version dieses Modells, jedoch mit bidirektionalem Encoder, wurde in vorgestellt
http://arxiv.org/abs/1409.0473
und gesampelter Softmax wird in Abschnitt 3 des folgenden Dokuments beschrieben.
http://arxiv.org/abs/1412.2007
"""

def init (selbst,
source_vocab_size,
target_vocab_size,
Eimer,
Größe,
Anzahl_Ebenen,
max_gradient_norm,
Stapelgröße,
Lernrate,
learning_rate_decay_factor,
use_lstm=Falsch,
num_samples=512,
forward_only=Falsch,
dtype=tf.float32):
"""Modell erstellen.

Argumente:
source_vocab_size: Größe des Quellvokabulars.
target_vocab_size: Größe des Zielwortschatzes.
Buckets: eine Liste von Paaren (I, O), wobei I die maximale Eingabelänge angibt
die in diesem Bucket verarbeitet werden, und O gibt die maximale Ausgabe an
Länge. Trainingsinstanzen mit Eingaben, die länger als I sind, oder Ausgaben
länger als O wird zum nächsten Bucket geschoben und entsprechend aufgefüllt.
Wir nehmen an, dass die Liste sortiert ist, zB [(2, 4), (8, 16)].
Größe: Anzahl der Einheiten in jeder Schicht des Modells.
num_layers: Anzahl der Schichten im Modell.
max_gradient_norm: Gradienten werden maximal auf diese Norm beschnitten.
batch_size: die Größe der während des Trainings verwendeten Stapel;
die Modellkonstruktion ist unabhängig von batch_size, so kann es sein
nach der Initialisierung geändert werden, wenn dies zweckmäßig ist, z. B. für die Dekodierung.
learning_rate: Lernrate zu Beginn.
learning_rate_decay_factor: Verringert die Lernrate bei Bedarf um diesen Wert.
use_lstm: Wenn wahr, verwenden wir LSTM-Zellen anstelle von GRU-Zellen.
num_samples: Anzahl der Samples für gesampelten Softmax.
forward_only: Wenn gesetzt, konstruieren wir den Rückwärtsdurchgang nicht im Modell.
dtype: Der Datentyp, der zum Speichern interner Variablen verwendet werden soll.
"""
self.source_vocab_size = source_vocab_size
self.target_vocab_size = Ziel_vocab_size
self.buckets = Eimer
self.batch_size = Stapelgröße
self.learning_rate = tf.Variable(
float(learning_rate), trainierbar=False, dtype=dtype)
self.learning_rate_decay_op = self.learning_rate.assign(
self.learning_rate * learning_rate_decay_factor)
self.global_step = tf.Variable(0, trainierbar=False)

Wenn wir gesampeltes Softmax verwenden, benötigen wir eine Ausgabeprojektion.

output_projection = Keine
softmax_loss_function = Keine

Sampled Softmax macht nur Sinn, wenn wir weniger als die Vokabelgröße abtasten.

if num_samples > 0 and num_samples < self.target_vocab_size:
w_t = tf.get_variable("proj_w", [self.target_vocab_size, size], dtype=dtype)
w = tf.transpose(w_t)
b = tf.get_variable("proj_b", [self.target_vocab_size], dtype=dtype)
Ausgabe_Projektion = (w, b)

def sampled_loss (Etiketten, Eingaben):
Etiketten = tf.reshape(Etiketten, [-1, 1])
# Wir müssen den sampled_softmax_loss mit 32-Bit-Floats berechnen
# Vermeiden Sie numerische Instabilitäten.
local_w_t = tf.cast(w_t, tf.float32)
local_b = tf.cast(b, tf.float32)
local_inputs = tf.cast (Eingänge, tf.float32)
tf.cast zurückgeben (
tf.nn.sampled_softmax_loss(local_w_t, local_b, local_inputs, Etiketten,
num_samples, self.target_vocab_size),
dtyp)
softmax_loss_function = gesampelter_Verlust

Erstellen Sie die interne mehrschichtige Zelle für unser RNN.

def single_cell():
Rückgabe tf.nn.rnn_cell.GRUCell(Größe)
if use_lstm:
def single_cell():
Rückgabe tf.nn.rnn_cell.BasicLSTMCell (Größe)
Zelle = einzelne_Zelle()
wenn num_layers > 1:
cell = tf.nn.rnn_cell.MultiRNNCell([single_cell() for _ in range(num_layers)])

Die seq2seq-Funktion: Wir verwenden Embedding für die Eingabe und Aufmerksamkeit.

def seq2seq_f(encoder_inputs, decoder_inputs, do_decode):
return tf.contrib.legacy_seq2seq.embedding_attention_seq2seq(
Encoder_Eingänge,
Decoder_Eingänge,
Zelle,
num_encoder_symbols=source_vocab_size,
num_decoder_symbols=target_vocab_size,
Embedding_size=Größe,
Ausgabe_Projektion=Ausgabe_Projektion,
feed_ previous=do_decode,
dtyp=dtyp)

Feeds für Eingaben.

self.encoder_inputs = []
self.decoder_inputs = []
self.target_weights = []
for i in xrange(buckets[-1][0]): # Der letzte Bucket ist der größte.
self.encoder_inputs.append(tf.placeholder(tf.int32, shape=[None],
name="encoder{0}".format(i)))
für i in xrange(buckets[-1][1] + 1):
self.decoder_inputs.append(tf.placeholder(tf.int32, shape=[None],
name="decoder{0}".format(i)))
self.target_weights.append(tf.placeholder(dtype, shape=[None],
name="weight{0}".format(i)))

Unsere Ziele sind um eins verschobene Decodereingänge.

Ziele = [self.decoder_inputs[i + 1]
für i in xrange(len(self.decoder_inputs) - 1)]

Trainingsleistungen und -verluste.

if forward_only:
self.outputs, self.losses = tf.contrib.legacy_seq2seq.model_with_buckets(
self.encoder_inputs, self.decoder_inputs, Ziele,
self.target_weights, Buckets, Lambda x, y: seq2seq_f(x, y, True),
softmax_loss_function=softmax_loss_function)
# Wenn wir Ausgabeprojektion verwenden, müssen wir Ausgaben für die Dekodierung projizieren.
wenn output_projection nicht None ist:
für b in xrange(len(buckets)):
self.outputs[b] = [
tf.matmul(Ausgabe, Ausgabe_Projektion[0]) + Ausgabe_Projektion[1]
für die Ausgabe in self.outputs[b]
]
anders:
self.outputs, self.losses = tf.contrib.legacy_seq2seq.model_with_buckets(
self.encoder_inputs, self.decoder_inputs, Ziele,
self.target_weights, Eimer,
Lambda x, y: seq2seq_f(x, y, False),
softmax_loss_function=softmax_loss_function)

Gradienten und SGD-Aktualisierungsvorgang zum Trainieren des Modells.

params = tf.trainable_variables()
wenn nicht forward_only:
self.gradient_norms = []
self.updates = []
opt = tf.train.GradientDescentOptimizer(self.learning_rate)
für b in xrange(len(buckets)):
gradients = tf.gradients(self.losses[b], params)
clipped_gradients, norm = tf.clip_by_global_norm(gradients,
max_gradient_norm)
self.gradient_norms.append(norm)
self.updates.append(opt.apply_gradients(
zip(clipped_gradients, params), global_step=self.global_step))

self.saver = tf.train.Saver(tf.global_variables())

def step(self, session, encoder_inputs, decoder_inputs, target_weights,
Bucket_id, forward_only):
"""Führen Sie einen Schritt des Modells aus, indem Sie die gegebenen Eingaben speisen.

Argumente:
Sitzung: Zu verwendende Tensorflow-Sitzung.
encoder_inputs: Liste von numpy int-Vektoren, die als Encoder-Eingänge eingespeist werden sollen.
decoder_inputs: Liste von numpy int-Vektoren, die als Decoder-Eingänge eingespeist werden sollen.
target_weights: Liste von numpy Float-Vektoren, die als Zielgewichte gefüttert werden sollen.
Bucket_id: welcher Bucket des Modells verwendet werden soll.
forward_only: ob der Schritt rückwärts oder nur vorwärts gemacht werden soll.

Kehrt zurück:
Ein Tripel bestehend aus Gradientennorm (oder None, wenn wir es nicht rückwärts gemacht haben),
durchschnittliche Ratlosigkeit, und die Ausgänge.

Erhöhungen:
ValueError: wenn Länge von encoder_inputs, decoder_inputs, or
target_weights stimmt nicht mit der Bucket-Größe für die angegebene Bucket_id überein.
"""

Überprüfen Sie, ob die Größen übereinstimmen.

encoder_size, decoder_size = self.buckets[bucket_id]
if len(encoder_inputs) != encoder_size:
raise ValueError("Encoder-Länge muss gleich der im Bucket sein,"
" %d != %d." % (länge(Encoder_Eingänge), Encoder_Größe))
if len(decoder_inputs) != decoder_size:
raise ValueError("Decoderlänge muss gleich der im Bucket sein,"
" %d != %d." % (länge(decoder_eingänge), decoder_größe))
if len(target_weights) != decoder_size:
raise ValueError("Gewichtslänge muss gleich der im Bucket sein,"
" %d != %d." % (len(target_weights), decoder_size))

Input-Feed: Encoder-Eingänge, Decoder-Eingänge, target_weights, wie bereitgestellt.

input_feed = {}
für l in xrange(encoder_size):
input_feed[self.encoder_inputs[l].name] = encoder_inputs[l]
für l in xrange(decoder_size):
input_feed[self.decoder_inputs[l].name] = decoder_inputs[l]
input_feed[self.target_weights[l].name] = target_weights[l]

Da unsere Ziele um eins verschobene Decodereingänge sind, brauchen wir einen mehr.

last_target = self.decoder_inputs[decoder_size].name
input_feed[last_target] = np.zeros([self.batch_size], dtype=np.int32)

Output-Feed: hängt davon ab, ob wir einen Rückwärtsschritt machen oder nicht.

wenn nicht forward_only:
output_feed = [self.updates[bucket_id], # Aktualisierungsoperation, die SGD ausführt.
self.gradient_norms[bucket_id], # Gradientennorm.
self.losses[bucket_id]] # Verlust für diesen Batch.
anders:
output_feed = [self.losses[bucket_id]] # Verlust für diesen Batch.
for l in xrange(decoder_size): # Logits ausgeben.
output_feed.append(self.outputs[bucket_id][l])

Ausgaben = session.run (Ausgabe_Feed, Eingabe_Feed)
wenn nicht forward_only:
Rückgabeausgänge[1], Ausgänge[2], Keine # Gradientennorm, Verlust, keine Ausgänge.
anders:
return Keine, Ausgänge[0], Ausgänge[1:] # Keine Gradientennorm, Verlust, Ausgänge.

def get_batch(selbst, Daten, Bucket_id):
"""Einen zufälligen Datenstapel aus dem angegebenen Bucket abrufen, Schritt vorbereiten.

Um Daten in step(..) einzuspeisen, muss es sich um eine Liste von Batch-Major-Vektoren handeln, während
Die Daten hier enthalten Großbuchstaben mit einfacher Länge. Also die Hauptlogik davon
Funktion besteht darin, Datenfälle neu zu indizieren, damit sie das richtige Format für die Eingabe haben.

Argumente:
data: ein Tupel der Größe len(self.buckets), in dem jedes Element enthalten ist
Listen von Paaren von Eingabe- und Ausgabedaten, die wir verwenden, um einen Stapel zu erstellen.
Bucket_id: Ganzzahl, für welchen Bucket der Batch abgerufen werden soll.

Kehrt zurück:
Das Tripel (encoder_inputs, decoder_inputs, target_weights) für
der erstellte Stapel, der das richtige Format hat, um später step(...) aufzurufen.
"""
encoder_size, decoder_size = self.buckets[bucket_id]
Encoder_Eingänge, Decoder_Eingänge = [], []

Holen Sie sich einen zufälligen Batch von Encoder- und Decoder-Eingaben aus Daten,

Füllen Sie sie bei Bedarf auf, kehren Sie die Encoder-Eingänge um und fügen Sie GO zum Decoder hinzu.

für _ in xrange(self.batch_size):
encoder_input, decoder_input = random.choice(data[bucket_id])

# Encoder-Eingänge werden aufgefüllt und dann umgekehrt.
encoder_pad = [data_utils.PAD_ID] * (encoder_size - len(encoder_input))
encoder_inputs.append(list(umgekehrt(encoder_input + encoder_pad)))

# Decoder-Eingänge erhalten ein zusätzliches "GO"-Symbol und werden dann aufgefüllt.
decoder_pad_size = decoder_size - len(decoder_eingang) - 1
decoder_inputs.append([data_utils.GO_ID] + decoder_input +
[data_utils.PAD_ID] * decoder_pad_size)

Jetzt erstellen wir Batch-Major-Vektoren aus den oben ausgewählten Daten.

batch_encoder_inputs, batch_decoder_inputs, batch_weights = [], [], []

Batch-Encoder-Eingänge sind nur neu indizierte encoder_inputs.

für length_idx in xrange(encoder_size):
batch_encoder_inputs.append(
np.array([encoder_inputs[batch_idx][length_idx]
für batch_idx in xrange(self.batch_size)], dtype=np.int32))

Batch-Decoder-Eingänge werden neu indiziert decoder_inputs, wir erstellen Gewichte.

für length_idx in xrange(decoder_size):
batch_decoder_inputs.append(
np.array([decoder_inputs[batch_idx][length_idx]
für batch_idx in xrange(self.batch_size)], dtype=np.int32))

# Erstellen Sie target_weights auf 0 für Ziele, die aufgefüllt werden.
batch_weight = np.ones (self.batch_size, dtype=np.float32)
für batch_idx in xrange(self.batch_size):
# Wir setzen das Gewicht auf 0, wenn das entsprechende Ziel ein PAD-Symbol ist.
# Das entsprechende Ziel ist decoder_input um 1 nach vorne verschoben.
if length_idx < decoder_size - 1:
Ziel = decoder_inputs[batch_idx][length_idx + 1]
if length_idx == decoder_size - 1 oder target == data_utils.PAD_ID:
batch_weight[batch_idx] = 0,0
batch_weights.append(batch_weight)
return batch_encoder_inputs, batch_decoder_inputs, batch_weights`

—
Sie erhalten dies, weil Sie erwähnt wurden.
Antworten Sie direkt auf diese E-Mail und zeigen Sie sie auf GitHub an
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312679587 ,
oder den Thread stumm schalten
https://github.com/notifications/unsubscribe-auth/ABtim0l5UMHHtbL1sz7meXserV8NVS7cks5sKQzXgaJpZM4MWl4f
.

Okay! trotzdem danke! :)

@ebrevdo gibt es ein Update darüber, wann das neue Tutorial von seq2seq mit neuer API herauskommen wird?
Danke schön. Erstaunliche Arbeit!.

Ja, ich warte auf das neue Tutorial ... wäre toll zu wissen, ob es geplant ist, bald veröffentlicht zu werden. @ebrevdo

versuchte, Code in die Kernel-Tests zu nehmen und die Strahlsuche mit dem Legacy-seq2seq nachzurüsten, aber es war eine Herausforderung ...

Wir hoffen auf diese kommende Woche!

Am 3. Juli 2017 um 10:16 Uhr schrieb "prashantserai" [email protected] :

Ja, ich warte auf das neue Tutorial ... wäre toll zu wissen, ob es das ist
geplant, bald veröffentlicht zu werden.. @ebrevdo
https://github.com/ebrevdo

versucht, Code in den Kernel zu testen und die Strahlsuche mit nachzurüsten
das alte seq2seq, aber es schien eine Herausforderung zu sein ...

—
Sie erhalten dies, weil Sie erwähnt wurden.
Antworten Sie direkt auf diese E-Mail und zeigen Sie sie auf GitHub an
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312697274 ,
oder den Thread stumm schalten
https://github.com/notifications/unsubscribe-auth/ABtim45-HTuQrIRDhphqqHjqkKOKTe53ks5sKSHYgaJpZM4MWl4f
.

Hallo Leute,

Bei jedem Update zu diesem Problem erlebe ich dasselbe auf Tensorflow 1.1-GPU für Mac OS X

@tshi1983
Ich habe das gleiche Problem mit Tensorflow 1.1-GPU für Ubuntu.
Ich aktualisiere auf tf 1.2. Es funktioniert immer noch nicht.
Dann ändere ich die Funktion embedding_attention_seq2seq in file
tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py
zu dem, wie @fabiofumarola oben vorgeschlagen hat.
Jetzt beginnt das Training. Dekodierung habe ich noch nicht getestet.

Verschieben Sie den Code auf der Zellendefinition in seq2seq_f:

def seq2seq_f(encoder_inputs, decoder_inputs, do_decode):
      def single_cell():
        return tf.contrib.rnn.GRUCell(size)
      if use_lstm:
        def single_cell():
          return tf.contrib.rnn.BasicLSTMCell(size)
      cell = single_cell()
      if num_layers > 1:
        cell = tf.contrib.rnn.MultiRNNCell([single_cell() for _ in range(num_layers)])
      return tf.contrib.legacy_seq2seq.embedding_attention_seq2seq(
      ...
      )

Dann kann "python translate.py --data_dir data/ --train_dir checkpoint/ --size=256 --num_layers=2 --steps_per_checkpoint=50" funktionieren.

@huxuanlai es funktioniert! Wenigstens ist jetzt Training, thx!

@huxuanlai Funktioniert auch für mich.

Ich erhalte dasselbe AttributeError: 'NoneType' object has no attribute 'update' , aber mit tf.contrib.legacy_seq2seq.model_with_buckets . Ich verwende tf 1.2.1 (GPU) auf Ubuntu 16.04 lts.

Dies scheint nur aufzutreten, wenn ich mehr als 1 Eimer habe.

Vollständige Rückverfolgung:

Traceback (most recent call last):
  File "chatbot.py", line 262, in <module>
    main()
  File "chatbot.py", line 257, in main
    train()
  File "chatbot.py", line 138, in train
    model.build_graph()
  File "/home/jkarimi91/Projects/cs20/code/hw/a3/model.py", line 134, in build_graph
    self._create_loss()
  File "/home/jkarimi91/Projects/cs20/code/hw/a3/model.py", line 102, in _create_loss
    softmax_loss_function=self.softmax_loss_function)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", line 1206, in model_with_buckets
    decoder_inputs[:bucket[1]])
  File "/home/jkarimi91/Projects/cs20/code/hw/a3/model.py", line 101, in <lambda>
    lambda x, y: _seq2seq_f(x, y, False),
  File "/home/jkarimi91/Projects/cs20/code/hw/a3/model.py", line 76, in _seq2seq_f
    feed_previous=do_decode)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", line 848, in embedding_attention_seq2seq
    encoder_cell = copy.deepcopy(cell)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 174, in deepcopy
    y = copier(memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/site-packages/tensorflow/python/layers/base.py", line 476, in __deepcopy__
    setattr(result, k, copy.deepcopy(v, memo))
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 163, in deepcopy
    y = copier(x, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 230, in _deepcopy_list
    y.append(deepcopy(a, memo))
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 190, in deepcopy
    y = _reconstruct(x, rv, 1, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 334, in _reconstruct
    state = deepcopy(state, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 163, in deepcopy
    y = copier(x, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 257, in _deepcopy_dict
    y[deepcopy(key, memo)] = deepcopy(value, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 190, in deepcopy
    y = _reconstruct(x, rv, 1, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 334, in _reconstruct
    state = deepcopy(state, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 163, in deepcopy
    y = copier(x, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 257, in _deepcopy_dict
    y[deepcopy(key, memo)] = deepcopy(value, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 190, in deepcopy
    y = _reconstruct(x, rv, 1, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 334, in _reconstruct
    state = deepcopy(state, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 163, in deepcopy
    y = copier(x, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 257, in _deepcopy_dict
    y[deepcopy(key, memo)] = deepcopy(value, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 190, in deepcopy
    y = _reconstruct(x, rv, 1, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 334, in _reconstruct
    state = deepcopy(state, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 163, in deepcopy
    y = copier(x, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 257, in _deepcopy_dict
    y[deepcopy(key, memo)] = deepcopy(value, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 163, in deepcopy
    y = copier(x, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 257, in _deepcopy_dict
    y[deepcopy(key, memo)] = deepcopy(value, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 163, in deepcopy
    y = copier(x, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 230, in _deepcopy_list
    y.append(deepcopy(a, memo))
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 190, in deepcopy
    y = _reconstruct(x, rv, 1, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 334, in _reconstruct
    state = deepcopy(state, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 163, in deepcopy
    y = copier(x, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 257, in _deepcopy_dict
    y[deepcopy(key, memo)] = deepcopy(value, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 190, in deepcopy
    y = _reconstruct(x, rv, 1, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 334, in _reconstruct
    state = deepcopy(state, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 163, in deepcopy
    y = copier(x, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 257, in _deepcopy_dict
    y[deepcopy(key, memo)] = deepcopy(value, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 190, in deepcopy
    y = _reconstruct(x, rv, 1, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 334, in _reconstruct
    state = deepcopy(state, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 163, in deepcopy
    y = copier(x, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 257, in _deepcopy_dict
    y[deepcopy(key, memo)] = deepcopy(value, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 163, in deepcopy
    y = copier(x, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 230, in _deepcopy_list
    y.append(deepcopy(a, memo))
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 163, in deepcopy
    y = copier(x, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 237, in _deepcopy_tuple
    y.append(deepcopy(a, memo))
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 163, in deepcopy
    y = copier(x, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 257, in _deepcopy_dict
    y[deepcopy(key, memo)] = deepcopy(value, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 190, in deepcopy
    y = _reconstruct(x, rv, 1, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 334, in _reconstruct
    state = deepcopy(state, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 163, in deepcopy
    y = copier(x, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 257, in _deepcopy_dict
    y[deepcopy(key, memo)] = deepcopy(value, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 190, in deepcopy
    y = _reconstruct(x, rv, 1, memo)
  File "/home/jkarimi91/Apps/anaconda2/envs/tf/lib/python2.7/copy.py", line 343, in _reconstruct
    y.__dict__.update(state)
AttributeError: 'NoneType' object has no attribute 'update'

@Tshzzz @jtubert
thx, deine Lösung hat bei mir funktioniert. Meine tf-Version ist 1.1.0.

Ich wechselte von:

    lstm_cell = tf.contrib.rnn.BasicLSTMCell(HIDDEN_SIZE, state_is_tuple=True)
    cell = tf.contrib.rnn.MultiRNNCell([lstm_cell() for _ in range(NUM_LAYERS)])
    output, _ = tf.nn.dynamic_rnn(cell, X, dtype=tf.float32)  

zu:

    cells=[]
    for _ in range(NUM_LAYERS):
        cell = tf.contrib.rnn.BasicLSTMCell(HIDDEN_SIZE, state_is_tuple=True)
        cells.append(cell)
    multicell = tf.contrib.rnn.MultiRNNCell(cells, state_is_tuple=True)
    output, _ = tf.nn.dynamic_rnn(multicell, X, dtype=tf.float32)

Dies ist immer noch nicht behoben, habe alle möglichen Lösungen ausprobiert, die in diesem Thread und Stackoverflow erwähnt wurden, es funktioniert nicht mit Tensorflow 1.3 oder 1.2 oder 1.1

Ich stehe vor diesem Fehler:
TypeError: embedding_attention_seq2seq() missing 1 required positional argument: 'dec_cell'

Der Fehler zeigt auf diese Funktion in seq2seq_model.py, die Zeile 142 in seq2seq_model.py ist:

def seq2seq_f(encoder_inputs, decoder_inputs, do_decode): return tf.contrib.legacy_seq2seq.embedding_attention_seq2seq( encoder_inputs, decoder_inputs, cell, num_encoder_symbols=source_vocab_size, num_decoder_symbols=target_vocab_size, embedding_size=size, output_projection=output_projection, feed_previous=do_decode, dtype=dtype)

Jeder, der auf diesen Fehler gestoßen ist und es geschafft hat, ihn zu lösen, hilft mir bitte, dieses Problem zu beheben.

ValueError: Versuch, RNNCell wiederzuverwendenmit einem anderen Variablenbereich als bei der ersten Verwendung. Die erste Verwendung von Zelle erfolgte mit dem Gültigkeitsbereich „rnn/multi_rnn_cell/cell_0/gru_cell“, dieser Versuch erfolgt mit dem Gültigkeitsbereich „rnn/multi_rnn_cell/cell_1/gru_cell“. Bitte erstellen Sie eine neue Instanz der Zelle, wenn Sie einen anderen Satz von Gewichtungen verwenden möchten. Wenn Sie zuvor Folgendes verwendet haben: MultiRNNCell([GRUCell(...)] * num_layers), wechseln Sie zu: MultiRNNCell([GRUCell(...) for _ in range(num_layers)]). Wenn Sie zuvor dieselbe Zelleninstanz sowohl als Vorwärts- als auch als Rückwärtszelle eines bidirektionalen RNN verwendet haben, erstellen Sie einfach zwei Instanzen (eine für Vorwärts, eine für Rückwärts). Im Mai 2017 werden wir damit beginnen, das Verhalten dieser Zelle so umzustellen, dass vorhandene gespeicherte Gewichtungen verwendet werden, falls vorhanden, wenn sie mit scope=None aufgerufen wird (was zu einer stillen Modellverschlechterung führen kann, sodass dieser Fehler bis dahin bestehen bleibt).

der Ursprungscode:
aus tensorflow.contrib import rnn
Eingaben = tf.placeholder(dtype=tf.int32, shape=[None, None], name="inputs")
keep_prob = tf.placeholder(dtype=tf.float32, name="keep_prob")
Zelle = rnn.GRUCell(10)
Zelle = rnn.DropoutWrapper (Zelle=Zelle, input_keep_prob=keep_prob)
cell = rnn.MultiRNNCell([cell for _ in range(5)], state_is_tuple=True)

outs, states = tf.nn.dynamic_rnn (cell=cell, input=look_up, dtype=tf.float32)
Lösung:
Eingaben = tf.placeholder(dtype=tf.int32, shape=[None, None], name="inputs")
keep_prob = tf.placeholder(dtype=tf.float32, name="keep_prob")
cell = rnn.MultiRNNCell([rnn.DropoutWrapper(rnn.GRUCell(10), input_keep_prob=keep_prob) for _ in range(5)] , state_is_tuple=True)

Hast du dieses Problem mit den tf Nightlies?

Am 1. Oktober 2017 um 8:34 Uhr schrieb „Baohua Zhou“ [email protected] :

Ich habe das gleiche Problem, wenn ich Tensorflow 1.1 auf einer CPU mit iOS verwende.

—
Sie erhalten dies, weil Sie erwähnt wurden.
Antworten Sie direkt auf diese E-Mail und zeigen Sie sie auf GitHub an
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-333384725 ,
oder den Thread stumm schalten
https://github.com/notifications/unsubscribe-auth/ABtimwOv7vf5vvFXBllbZryjCFwmJcU6ks5sn7DxgaJpZM4MWl4f
.

AttributeError: 'NoneType'-Objekt hat kein Attribut 'update'

bei tf=1,3

ValueError: Versuch, RNNCell wiederzuverwendenmit einem anderen Variablenbereich als bei der ersten Verwendung. Die erste Verwendung von Zelle erfolgte mit dem Bereich „embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_0/gru_cell“, dieser Versuch erfolgt mit dem Bereich „embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_1/gru_cell“. Bitte erstellen Sie eine neue Instanz der Zelle, wenn Sie einen anderen Satz von Gewichtungen verwenden möchten. Wenn Sie zuvor Folgendes verwendet haben: MultiRNNCell([GRUCell(...)] * num_layers), wechseln Sie zu: MultiRNNCell([GRUCell(...) for _ in range(num_layers)]). Wenn Sie zuvor dieselbe Zelleninstanz sowohl als Vorwärts- als auch als Rückwärtszelle eines bidirektionalen RNN verwendet haben, erstellen Sie einfach zwei Instanzen (eine für Vorwärts, eine für Rückwärts). Im Mai 2017 werden wir damit beginnen, das Verhalten dieser Zelle so umzustellen, dass vorhandene gespeicherte Gewichtungen verwendet werden, falls vorhanden, wenn sie mit scope=None aufgerufen wird (was zu einer stillen Modellverschlechterung führen kann, sodass dieser Fehler bis dahin bestehen bleibt).

Es sind 14 Tage ohne Aktivität vergangen und das Label awaiting tensorflower wurde zugewiesen. Bitte aktualisieren Sie das Label und/oder den Status entsprechend.

Nörgelndes Warten auf TensorFlower: Es sind 14 Tage ohne Aktivität vergangen und das Label awaiting tensorflower wurde zugewiesen. Bitte aktualisieren Sie das Label und/oder den Status entsprechend.

Die Lösung besteht darin, auf eine neuere Version von TF umzusteigen. Dieser Thread hat sich drastisch von seinem ursprünglichen Problem entfernt. Schließen.

Wenn Sie eine sofortige Lösung wünschen, können Sie versuchen, was ich versucht habe:

pip install tensorflow==1.0
Das Problem ist mit Tenorflow 1.1 Version, es hat bei mir funktioniert.