J'obtiens la même erreur lorsque j'essaie d'exécuter l'exemple de traduction (même lors du petit autotest) qui peut être trouvé ici : https://github.com/tensorflow/models/tree/master/tutorials/rnn/translate

J'ai rencontré le même problème. Si vous utilisez tous la version compilée sur la branche master, je pense que nous avons le même problème causé par le récent commit . Comme le dit le message de validation :

Faire en sorte que toutes les RNNCells dans tf.contrib.rnn agissent comme des couches tf.layers, mais avec une sémantique plus stricte pour non
w :

1. Lors de la première utilisation de __call__, la portée utilisée est stockée dans la cellule. Le RNNCell essaie de créer des poids dans cette portée, mais si certains sont déjà définis, une erreur est générée à moins que le RNNCell n'ait été construit avec l'argument reuse=True.

2. Une utilisation ultérieure de __call__ de la même instance de cellule doit être dans la même portée.
   Si ce n'est pas le cas, une erreur est levée.

Dans mon cas, qui exécute le tutoriel ptb , la solution consiste simplement à ajouter un paramètre nommé avec reuse comme ceci à la ligne 112 :

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

Alors ça marche.

@ebrevdo Pourriez-vous s'il vous plaît jeter un œil à cela?

Le problème se reproduit pour moi lors de l'utilisation de Windows/GPU build 105 sur le Shakespeare RNN Repo .

Lors de l'exécution du code avec la version Win 1.0.0/GPU, il n'y a aucun problème.

Ce référentiel semble cibler tf 1.0, pas les versions intermédiaires.

Le 8 mars 2017 à 15h56, "Tom Wanzek" [email protected] a écrit :

Le problème se reproduit pour moi lors de l'utilisation de Windows/GPU build 105 sur le Shakespeare
Dépôt RNN https://github.com/martin-gorner/tensorflow-rnn-shakespeare .

Lors de l'exécution du code avec la version Win 1.0.0/GPU, il n'y a aucun problème.

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285209555 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ABtim5ansaL1KN51T4nCaqLnqw2QHN4Wks5rj0BBgaJpZM4MWl4f
.

@tongda , j'utilise la version Release de Tensorflow 1.0, travaillant sur MacOS en mode CPU. Je vais passer à la branche master pour voir si cela fonctionne en ajoutant le paramètre "reuse", merci.

doncat99 : si c'est le cas, assurez-vous que votre code interroge la version de tensorflow
et lève un drapeau si la version est inférieure à la version de la branche principale.
vous devrez peut-être vérifier par rapport à :

à partir des versions d'importation de tensorflow.core
versions.GIT_VERSION

Le mercredi 8 mars 2017 à 18h58, doncat99 [email protected] a écrit :

@tongda https://github.com/tongda , j'utilise la version Release de
Tensorflow 1.0, fonctionnant sur MacOS en mode CPU. je vais passer au master
branche pour voir si cela fonctionne en ajoutant le paramètre "reuse", merci.

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285240438 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ABtim66cU9e16lgD-2D0QLGcQCiHbV0zks5rj2rbgaJpZM4MWl4f
.

@ebrevdo Alors, quelles seraient les modifications suggérées au RNN de Shakepeare pour lui permettre de fonctionner avec la version stable intermédiaire ?

Voici la section architecturale clé du code, qui échoue maintenant avec le build#105 :

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

Je ne semble pas trouver de documentation concernant un drapeau reuse ?

Merci d'avance.

Utiliser:

multicell = rnn.MultiRNNCell([rnn.DropoutWrapper(rnn.GRUCell(INTERNALSIZE),
input_keep_prob=pkeep) pour _ dans la plage (NLAYERS)], state_is_tuple=False)

Ce qui crée un objet grucell séparé pour chaque couche.

Le 10 mars 2017 à 7h44, "Tom Wanzek" [email protected] a écrit :

@ebrevdo https://github.com/ebrevdo Alors, quelle serait la proposition
modifications apportées au Shakepeare RNN pour lui permettre de fonctionner avec l'intermédiaire
version stable?

Voici la section architecturale clé du code, qui échoue maintenant avec
build#105 :

le modèle (voir FAQ dans README.md)

lr = tf.placeholder(tf.float32, name='lr') # taux d'apprentissage
pkeep = tf.placeholder(tf.float32, name='pkeep') # paramètre d'abandon
batchsize = tf.placeholder(tf.int32, name='batchsize')

contributions

X = tf.placeholder(tf.uint8, [None, None], name='X') # [ BATCHSIZE, SEQLEN ]
Xo = tf.one_hot(X, ALPHASIZE, 1.0, 0.0) # [ BATCHSIZE, SEQLEN, ALPHASIZE ]# sorties attendues = même séquence décalée de 1 puisque nous essayons de prédire le caractère suivant
Y_ = tf.placeholder(tf.uint8, [Aucun, Aucun], name='Y_') # [ BATCHSIZE, SEQLEN ]
Yo_ = tf.one_hot(Y_, ALPHASIZE, 1.0, 0.0) # [ BATCHSIZE, SEQLEN, ALPHASIZE ]# état d'entrée
Hin = tf.placeholder(tf.float32, [None, INTERNALSIZE*NLAYERS], name='Hin') # [ BATCHSIZE, INTERNALSIZE * NLAYERS]

en utilisant un NLAYERS=3 couches de cellules GRU, déroulées SEQLEN=30 fois# dynamic_rnn déduit SEQLEN de la taille des entrées Xo

unecellule = rnn.GRUCell(TAILLE INTERNE)
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 ] # c'est le dernier état dans la séquence

Je ne semble pas trouver de documentation concernant un drapeau de réutilisation ?

Merci d'avance.

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285702372 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ABtim6MOOCbx3RJEJe8PQBDXGVIXTGPmks5rkW_jgaJpZM4MWl4f
.

Je ne comprends pas pourquoi j'obtiens cette erreur avec le modèle de tutoriel seq2seq :

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

La source

où la cellule est créée avec

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

@ebrevdo Merci d'être revenu sur ce problème. Malheureusement, le changement suggéré laisse les choses telles qu'elles sont, avec l'erreur susmentionnée. Compte tenu du commentaire ci-dessus concernant le tutoriel seq2seq , je soupçonne que nous sommes tous dans le même bateau ?

Es-tu sûr que c'est exactement la même erreur ? Veuillez le copier et le coller ici.

Mon mauvais, je viens de recommencer le processus de modification du code pertinent (à partir de zéro) et de le relancer comme proposé. L'erreur a en effet été supprimée et le Vieux Barde hallucine très bien maintenant 👍

Donc, merci, je ne sais pas où je me suis trompé hier, mais c'était clairement sur moi.

J'ai rencontré le même problème lorsque j'utilisais la version Release de Tensorflow 1.0 et que je travaillais sur MacOS en mode cpu.Même si j'ajoute le paramètre "reuse"

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)

votre multicellule a l'air faux... vous devriez utiliser "cell() pour _ dans
intervalle(...)"

Le jeudi 16 mars 2017 à 20h29, cuiming [email protected] a écrit :

J'ai rencontré le même problème lors de l'utilisation de la version Release de Tensorflow 1.0
et travailler sur MacOS en mode cpu.Même si ajouter le paramètre "reuse"

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

muticell = tf.contrib.rnn.MultiRNNCell([cellule pour _ dans la plage(num_layers)], state_is_tuple=True)

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-287257629 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ABtim3A6JQr8ptRKrdiDW_kgNRIFkHGlks5rmf4WgaJpZM4MWl4f
.

J'essayais d'exécuter l'exemple de traduction : python2.7 translate.py --data_dir data/ --train_dir train/ --size=256 --num_layers=2 --steps_per_checkpoint=50

Il semble que la façon d'utiliser MultiRNNCell soit correcte :
cellule = tf.contrib.rnn.MultiRNNCell([single_cell() for _ in range(num_layers)])

Mais j'ai la même erreur :
ValueError : tentative de réutilisation de RNNCellavec un périmètre variable différent de sa première utilisation. La première utilisation de la cellule était avec la portée 'embedding_attention_seq2seq/embedding_attention_decoder/attention_decoder/multi_rnn_cell/cell_0/gru_cell', cette tentative est avec la portée 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_0/gru_cell'. Veuillez créer une nouvelle instance de la cellule si vous souhaitez qu'elle utilise un ensemble de pondérations différent. Si vous utilisiez auparavant : MultiRNNCell([GRUCell(...)] * num_layers), remplacez-le par : MultiRNNCell([GRUCell(...) for _ in range(num_layers)]). Si auparavant vous utilisiez la même instance de cellule comme cellule aller et retour d'un RNN bidirectionnel, créez simplement deux instances (une pour aller, une pour inverse). En mai 2017, nous commencerons la transition du comportement de cette cellule pour utiliser les pondérations stockées existantes, le cas échéant, lorsqu'elle est appelée avec scope=None (ce qui peut entraîner une dégradation silencieuse du modèle, donc cette erreur persistera jusque-là.)

@bowu - avez-vous eu de la chance avec ça ? si vous ne l'avez pas encore essayé, réinstallez tensorflow à partir de la dernière source. il y a eu quelques changements dans certains des fichiers core_rnn, parmi quelques autres. fonctionne pour moi maintenant.

@robmsylvester Je réinstalle tensorflow à partir de la dernière source, toujours la même erreur. J'étais sur la branche master et le dernier commit est commit 2a4811054a9e6b83e1f5a2705a92aab50e151b13 . Quel est le dernier commit lorsque vous construisez votre dépôt ?

Bonjour, j'utilise Tensorflow r1.0 en utilisant un GPU construit à l'aide de la source. J'essaie de suivre le didacticiel de traduction Seq2Seq non modifié, mais j'obtiens la même erreur. c'est à dire

ValueError : tentative de réutilisation de RNNCellavec un périmètre variable différent de sa première utilisation. La première utilisation de la cellule était avec la portée 'embedding_attention_seq2seq/embedding_attention_decoder/attention_decoder/multi_rnn_cell/cell_0/gru_cell', cette tentative est avec la portée 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_0/gru_cell' .....

La partie pertinente du code dans mon seq2seq_model.py est :

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

Que puis-je faire pour résoudre le problème ?

ajouter "reuse=tf.get_variable_scope().reuse" à l'appel où le GRUCell est créé n'aide pas.

Merci beaucoup!

@prashantserai - voyez ce qui se passe si vous supprimez la ligne MultiRNNCell d'en haut, ce qui fait de votre réseau une seule couche. Ça marche alors ? Il pourrait s'agir d'un bogue quelque part dans MultiRNNCell. J'ai lu à ce sujet quelque part récemment, probablement sur un débordement de pile.

Si vous implémentez vous-même le lstm/gru empilé, vous n'obtenez pas cette erreur et vous pouvez implémenter la même fonctionnalité (en fait plus, car vous êtes libre de faire ce que vous voulez avec des architectures bidirectionnelles, des connexions résiduelles et ignorées étranges, etc. .)

@robmsylvester La même erreur a persisté même lorsque j'ai essayé avec num_layers=1 qui devrait effectivement ignorer cette ligne. D'autres idées ? Merci pour la contribution.

Hmmm. Une chose qui ressort pour moi est dans le fichier seq2seq hérité référencé :

encoder_cell = copy.deepcopy(cell)

Cette ligne semble être utilisée car la même architecture est utilisée côté codeur et côté décodeur. Ils font une copie de la cellule, puis transmettent l'argument de la cellule à la fonction d'intégration du décodeur d'attention, puis au décodeur d'attention lui-même.

Que se passe-t-il si vous créez explicitement la cellule d'encodeur ET la cellule de décodeur dans votre fichier de modèle seq2seq et que vous transmettez les deux au fichier de bibliothèque hérité, en apportant de petits ajustements aux fonctions et à leurs arguments ?

@robmsylvester ne devrait-il pas modifier la portée des cellules ? Cela fonctionne également pour les deux autres exemples. À mon avis, ce serait une solution de contournement très laide; une solution plus propre doit exister ; peut-être qu'il nous manque quelque chose ? (J'ai également eu la même erreur sur le tutoriel seq2seq, j'ai essayé toutes les solutions ci-dessus).

@ iamgroot42 - Ouais, cette "solution" est certes très laide, mais plus encore en essayant de rechercher où pourrait se trouver un problème. Je vais jouer avec dans quelques heures et voir si je peux trouver quelque chose.

En fait, le copy.deepcopy est là parce que ce sont des fonctions héritées et
nous n'avons pas les ressources pour les maintenir/mettre à jour. Si vous souhaitez
introduire une modification rétrocompatible qui permet à l'utilisateur de fournir un
deuxième cellule pour l'étape de décodage, et si c'est Aucun alors se replier sur le
deepcopy, alors je serais heureux d'examiner le PR. Gardez à l'esprit que ce serait
doit être un changement rétrocompatible.

Le mar. 4 avril 2017 à 11h38, Rob Sylvester [email protected]
a écrit:

@iamgroot42 https://github.com/iamgroot42 - Ouais, cette "solution" est
certes très moche, mais plus encore juste essayer de traquer où un problème
pourrait être. Je vais jouer avec dans quelques heures et voir si je peux suivre quelque chose
vers le bas.

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-291593289 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ABtim1QHTDhOC_zT6cKtmUFPOit5Yjn7ks5rso5CgaJpZM4MWl4f
.

@ebrevdo - Je vais y réfléchir. J'ai un traducteur qui fonctionne assez similaire à celui-ci mais crée des cellules via une classe distincte qui permet d'insérer des couches bidirectionnelles où vous voulez, des résidus où vous voulez, de fusionner des entrées avec concat vs sum, et quelques autres choses. Je pense que je pourrais migrer ma classe vers ce tutoriel assez facilement en utilisant des RNN statiques. Je vous tiendrai au courant.

@ebrevdo j'utilise Tensorflow r1.0 (tensorflow-1.0.1-cp36-cp36m-linux_x86_64) sur Red Hat et j'ai la dernière version du didacticiel de traduction de Github .. existe-t-il un moyen que vous connaissiez pour que cela fonctionne actuellement?

Il est dommage que le tutoriel de traduction ne fonctionne pas avec TF 1.0. On devrait régler ça. @lukaszkaiser pouvez-vous jeter un œil ? Nous travaillons sur un nouveau tutoriel mais il reste encore quelques semaines et nécessitera une version nocturne de TensorFlow (ou TF 1.1 ou 1.2) pour fonctionner.

(lukasz; il m'est difficile d'identifier à partir des différents commentaires quelle partie du didacticiel est défectueuse dans TF 1.0. Si vous pouviez identifier la ligne et que je puisse vous aider à la faire fonctionner ?)

@ebrevdo C'est ce tutoriel. L'erreur se trouve dans ce groupe de lignes. Les cellules transmises ici sont utilisées à la fois pour la phase arrière et avant du modèle seq2seq hérité, qui génère une erreur car les mêmes cellules sont utilisées avec des portées différentes.

@iamgroot42 voulez-vous faire un PR avec les changements nécessaires ? Ce serait formidable, je n'ai actuellement pas les cycles pour le faire moi-même. Merci!

J'ai remarqué que le TF 1.0 fonctionne bien avec la dernière version du didacticiel de traduction s'il est compilé à partir de la source sur branch remotes/origin/r1.0

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

puis construisez et installez TensorFlow, cela fonctionne bien.

Sur la branche remotes/origin/r1.1, il y a l'erreur "portée variable différente".
J'ai modifié le code comme suggéré par @robmsylvester

Que se passe-t-il si vous créez explicitement la cellule d'encodeur ET la cellule de décodeur dans votre fichier de modèle seq2seq et que vous transmettez les deux au fichier de bibliothèque hérité, en apportant de petits ajustements aux fonctions et à leurs arguments ?

et ça marche pour moi maintenant.

@oxwsds le Tensorflow que j'utilise est 1.0.1 donc peut-être qu'il y a une erreur ..

J'avais essayé ce que @robmsylvester suggérait alors en fait.. et la formation avait commencé (2 jours 13 heures fait maintenant).. il échoue lors du décodage mais avec l'erreur :

  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)

As-tu essayé de décoder ?

@prashantserai Je ne sais pas exactement, mais ce que vous avez rencontré semble être un autre problème.

@prashantserai S'il échoue uniquement lorsque vous décodez, cela a peut-être quelque chose à voir avec l'utilisation d'une taille de lot d'un ? Le modèle s'entraîne-t-il toujours si vous réduisez la taille du lot à un pendant l'entraînement ?

@bowu Même erreur ici. Mac OX Sierra, TensorFlow 1.1.0-rc1, Python 2.7.10 et Python 3.6.1.

@robmsylvester , il s'est entraîné avec succès avec une taille de lot de un également, mais a échoué lors du décodage de la même manière ou d'une manière similaire .. voici une trace complète .. la raison pour laquelle je pensais à cela comme une erreur connectée était à cause de la référence à seq2seq_f (qui était l'une des fonctions modifiées) (le commentaire #prashant de mon code pour signifier qu'une ligne modifiée fait partie de la trace)

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 votre opinion change-t-elle sur la base de la trace complète ci-dessus ?

@prashantserai J'ai essayé de décoder et ça marche bien. J'ajoute simplement un argument encoder_cell à la fonction tf.contrib.legacy_seq2seq.embedding_attention_seq2seq et dans translate/seq2seq_model.py créer la cellule et la transmettre à la fonction, qui a été appelée dans la fonction seq2seq_f . Comment as-tu changé ton code ?

@oxwsds @robmsylvester @ebrevdo
J'ai enfin quelque chose qui fonctionne maintenant (je veux dire, les résultats pour mon réseau à une seule couche de 256 unités sont plutôt épouvantables, mais c'est probablement juste parce que le réseau est ultra léger et que je n'ai pas du tout réglé les paramètres)
Merci beaucoup à tous...!!!!!

_Voici mes pensées à la fin de ceci :_

@oxwsds commente que le tutoriel (dans sa forme actuelle) fonctionne sans aucune modification lorsque Tensorflow est compilé à partir de la branche remotes/origin/r1.0 était TRUE . Cependant, le plus triste était que la version de Tensorflow que j'avais pour laquelle des modifications dans le code Tensorflow étaient nécessaires, et la version dans remotes/origin/r1.0 étaient toutes deux étiquetées de manière identique.

Le correctif de @robmsylvester dans le commentaire (copié ci-dessous) A FONCTIONNÉ pour ma version de Tensorflow où le didacticiel n'a pas fonctionné immédiatement (et devrait également fonctionner pour TF 1.1, je suppose). C'est un peu brouillon à mettre en œuvre, mais je pourrais le faire, ce qui n'est pas peu dire :-P
L'erreur dans mes deux derniers commentaires avant cela était due à mon erreur. Comme un mannequin, je spécifiais les couches et les paramètres d'unités cachées uniquement pendant la formation, je laissais le code utiliser les valeurs par défaut lors du décodage. (cette partie du tutoriel pourrait être un peu plus factice : https://www.tensorflow.org/tutorials/seq2seq#lets_run_it )

Hmmm. Une chose qui ressort pour moi est dans le fichier seq2seq hérité référencé :

encoder_cell = copy.deepcopy(cell)

Cette ligne semble être utilisée car la même architecture est utilisée côté codeur et côté décodeur. Ils font une copie de la cellule, puis transmettent l'argument de la cellule à la fonction d'intégration du décodeur d'attention, puis au décodeur d'attention lui-même.

Que se passe-t-il si vous créez explicitement la cellule d'encodeur ET la cellule de décodeur dans votre fichier de modèle seq2seq et que vous transmettez les deux au fichier de bibliothèque hérité, en apportant de petits ajustements aux fonctions et à leurs arguments ?

Merci pour les commentaires! Il semble qu'il y ait quelque chose de différent entre le TF
sur pypi et à cette étiquette ? Gunhan, est-ce possible ?

Le lundi 10 avril 2017 à 21h05, prashantserai [email protected]
a écrit:

@oxwsds https://github.com/oxwsds @robmsylvester
https://github.com/robmsylvester @ebrevdo https://github.com/ebrevdo
J'ai enfin quelque chose qui fonctionne maintenant (je veux dire, des résultats pour mon single
réseau d'unités de couche 256 sont un peu épouvantables, mais c'est probablement juste
parce que le réseau est ultra léger et que je n'ai pas du tout réglé les paramètres)

Voici mon résultat :

@oxwsds https://github.com/oxwsds commente que le tutoriel (dans sonforme actuelle) fonctionne sans aucune modification lorsque Tensorflow estcompilé à partir de la branche remotes/origin/r1.0 était TRUE . Le peu triste
bien qu'étant que la version de Tensorflow que j'avais pour laquelle des modifications
dans le code Tensorflow étaient nécessaires, et la version dans remotes/origin/r1.0
étaient tous les deux étiquetés de manière identique.

@robmsylvester https://github.com/robmsylvester's fix in the comment
(copié ci-dessous) A FONCTIONNÉ pour ma version de Tensorflow où le tutoriel
n'a pas fonctionné hors de la boîte (et devrait également fonctionner pour TF 1.1, je suppose). Il est
un peu salissant à mettre en œuvre, mais je pourrais le faire, ce qui veut dire quelque chose
:-P
L'erreur dans mes deux derniers commentaires avant cela était due à mon erreur. Comme
un mannequin, je spécifiais uniquement les calques et les paramètres des unités cachées
pendant la formation, je quittais le code pour utiliser les valeurs par défaut lors du décodage. (cettepartie du didacticiel pourrait être une preuve légèrement plus factice :https://www.tensorflow.org/tutorials/seq2seq#lets_run_ithttps://www.tensorflow.org/tutorials/seq2seq#lets_run_it )

Hmmm. Une chose qui ressort pour moi est dans l'héritage référencé seq2seq
déposer:

encoder_cell = copy.deepcopy(cell)

Cette ligne semble être utilisée car la même architecture est utilisée sur les deux
côté codeur et décodeur. Ils font une copie de la cellule, puis passent le
argument de cellule avec la fonction d'intégration du décodeur d'attention, puis à
le décodeur d'attention lui-même.

Que se passe-t-il si vous créez explicitement la cellule d'encodeur ET le décodeur
cellule dans votre fichier de modèle seq2seq et transmettez les deux à la bibliothèque héritée
fichier, en faisant les petits ajustements des fonctions et de leurs arguments ?

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-293143828 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ABtimxvcfFnbWbpj7aUs3BUjwGEFj6p5ks5ruvvygaJpZM4MWl4f
.

Pour information, j'ai eu ce problème en essayant d'empiler des cellules LSTM :
Mon code d'origine était :

    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)

Ensuite, avec le code suivant, la création du modèle était correcte, mais je ne pouvais pas partager la variable avec un autre modèle. (par exemple si vous créez un train_model et un valid_model censés partager des tenseurs, cela échouera)

    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)

Donc finalement j'ai utilisé lstm_creator pour être la fonction comme lstm_cell dans tensorflow/models/tutorials/rnn/ptb/ptb_word_lm.py#L112 . J'ai maintenant:

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)

Il fonctionne maintenant pleinement

essayer de faire fonctionner cette chose, ce qui entraîne la même erreur:

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

La solution de @pltrdy ne l'a pas fait pour moi bizarrement. Je suis en train

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 avez-vous utilisé la fonction de https://github.com/tensorflow/models/blob/master/tutorials/rnn/ptb/ptb_word_lm.py#L112 que je mentionne à la fin de mon message (maintenant édité pour être plus clair )

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

ça a résolu mon problème

J'ai réussi à résoudre ce problème en installant une ancienne version de Tensorflow :
pip install -Iv tensorflow==1.0

Je recevais l'erreur lors de l'exécution du tutoriel seq2seq

En ce qui concerne ce que @ebrevdo a dit, je pense que la solution n'est pas de corriger le code seq2seq hérité, mais de mettre à jour le tutoriel pour utiliser le package contrib.seq2seq la place, qui est activement maintenu. C'est assez démoralisant lorsque le premier programme tensorflow que vous exécutez crache un tas d'erreurs. Si j'ai un peu de temps cette semaine, je soumettrai un PR.

Nous travaillons sur un nouveau tutoriel seq2seq. Nous avions espéré sortir d'ici la fin de
le mois dernier mais prennent du retard. Il utilisera la nouvelle API.

Le 1er mai 2017 à 8h07, "Kyle Teague" [email protected] a écrit :

En ce qui concerne ce que @ebrevdo https://github.com/ebrevdo a dit, je pense
la solution n'est pas de corriger l'ancien code seq2seq, mais de mettre à jour le
tutoriel pour utiliser le package contrib.seq2seq à la place, qui est activement
entretenu. C'est assez démoralisant lorsque le premier programme tensorflow vous
jamais courir crache un tas d'erreurs. Si j'ai un peu de temps cette semaine, je vais
soumettre un PR.

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-298350307 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ABtim587xZx9Gi4-yXmwccSum8_Trc1oks5r1fUogaJpZM4MWl4f
.

@ebrevdo Je rencontre la même erreur lors de l'exécution du modèle sequence_to_sequence sur le site Web tensorflow1.1. Et j'ai essayé d'utiliser le paramètre 'reuse' mais j'ai échoué. Pourriez-vous me dire quand le nouveau tutoriel seq2seq sera publié ?

On dirait en même temps que tf 1.2, puisque nous allons nous appuyer sur quelques nouveautés
caractéristiques de cette version.

Le 4 mai 2017 à 21h16, "njuzrs" [email protected] a écrit :

@ebrevdo https://github.com/ebrevdo Je rencontre la même erreur lors de l'exécution
le modèle sequence_to_sequence sur le site Web tensorflow1.1. Et j'ai essayer
utiliser le paramètre 'reuse' mais a échoué. Pourriez-vous me dire quand le nouveau seq2seq
tutoriel sera publié?

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-299366774 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ABtim8_kFTM7-SsXQAA-Ar0dfhHMGT0Zks5r2qKngaJpZM4MWl4f
.

@ebrevdo Je suis également confronté au même problème et incapable de progresser avec seq2seq. Ce serait vraiment utile si vous pouviez nous faire savoir quelle est la date probable d'un nouveau tutoriel.
Merci beaucoup pour votre aide.

L'installation à l'aide pip install tensorflow==1.0 (Tensorflow 1.0) fonctionne pour moi (tutoriel de traduction).

J'ai la version 1.1.0-rc2.

TF1.2 résoudra ce problème ? S'il vous plaît, aidez-moi à continuer à former le modèle. TF 1.0 fonctionne mais n'a pas d'API devicewrapper pour plusieurs GPU.

Ayant le même problème avec le flux tenseur 1.1. Toujours en train de travailler sur une solution

J'ai essayé plusieurs choses, à la fin j'ai pu utiliser tensorflow 1.1 mais j'ai dû faire ces changements : (basé sur Tshzzz ci-dessus)

Enlève ça:
multicell = rnn.MultiRNNCell([dropcell]*NLAYERS, state_is_tuple=False)

Et ajoutez ceci :
cellules=[]
pour _ dans la plage (NLAYERS):
cellule = rnn.DropoutWrapper(tf.contrib.rnn.GRUCell(INTERNALSIZE), input_keep_prob=pkeep)
cellules.append(cellule)
multicellule = rnn.MultiRNNCell(cellules, state_is_tuple=False)

@ebrevdo Félicitations, TF 1.2 vient d'être publié - le nouveau tutoriel a-t-il également été publié quelque part ou est-il bientôt publié ?

Merci

Nous prévoyons de faire une annonce lors de sa sortie. J'y travaille.

Le 19 mai 2017 à 19h02, "prashantserai" [email protected] a écrit :

@ebrevdo https://github.com/ebrevdo Félicitations, TF 1.2 vient de recevoir
publié - le nouveau tutoriel a-t-il également été publié quelque part ou est-il en cours
bientôt publié ?

Merci

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-302844002 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ABtim0RWDzNCXk-bIjKSyHLvgFxUvq2lks5r7km7gaJpZM4MWl4f
.

Pour toute personne utilisant tensorflow-gpu==1.1.0 et obtenant cette erreur, passer à 1.0.0 via pip install tensorflow-gpu==1.0.0 ne résoudra pas le problème, du moins n'a pas fonctionné pour moi.

J'ai rencontré ce problème sur mac et ubuntu et la compilation à partir de la source a fonctionné les deux fois. Alors:
installation de pip https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.0.0-cp34-cp34m-linux_x86_64.whl

@ajaanbaahu Toujours en attente du nouveau tutoriel seq2seq de tf1.2.

Cela a fonctionné pour moi en utilisant pip install tensorflow==1.0 .

Pour tf r1.2, j'ai eu une erreur de copie profonde. Comme indiqué dans l'erreur de modèle de séquence à séquence # 1050

En tant que recrue, j'évoque une partie de mon opinion.
Le code suivant provoquera cette erreur similaire :
(Morceau de mon code)

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)

Le vidage d'erreur comme suit :

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

Mais après avoir fait la révision, ça peut marcher.

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

Aucune de ces solutions de contournement n'a fonctionné pour moi avec Tensorflow 1.1

J'utilise le modèle $#$ seq2seq MultiRNNCell .

J'ai dû revenir à la version 1.0.1 : pip3 install tensorflow==1.0

Quelqu'un a-t-il ces problèmes lorsqu'il travaille avec legacy_seq2seq.rnn_decoder() ?

@oxwsds Comme vous l'avez dit, je change la cellule d'entrée args de tf.contrib.legacy_seq2seq.embedding_attention_seq2seq en deux cellules différentes {encoder_cells, decoder_cells}. Enfin, je reçois le modèle seq2seq travaillé. Après 73200 setps, j'obtiens la perplexité 5.54.
Ensuite, je lance la partie décodage,

Qui est le président des États-Unis ?
Qui est le président des États-Unis ?

Problème résolu. Merci.

@doncat99
Il semble que copy.deepcopy(cell) dans seq2seq.py n'ait aucun effet.
Donc, je change la partie associée dans seq2seq_model.py en

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 , Pourriez-vous partager votre code ?

La mise à niveau vers Tensorflow 1.2.0 et la génération des cellules dans une boucle au lieu de la multiplication de liste ont corrigé cela pour moi.

J'ai eu l'erreur avec TF1.2 lors de l'exécution de translate.py, détails :
nom : GeForce GTX 1080 Ti
majeur : 6 mineur : 1 memoryClockRate (GHz) 1.582
pciBusID 0000:02:00.0
Mémoire totale : 10,91 Gio
Mémoire libre : 10,76 Gio
2017-06-22 09:15:04.485252 : Je tensorflow/core/common_runtime/gpu/gpu_device.cc:961] DMA : 0
2017-06-22 09:15:04.485256 : Je tensorflow/core/common_runtime/gpu/gpu_device.cc:971] 0 : Oui
2017-06-22 09:15:04.485265 : I tensorflow/core/common_runtime/gpu/gpu_device.cc:1030] Création d'un périphérique TensorFlow (/gpu:0) -> (périphérique : 0, nom : GeForce GTX 1080 Ti, pci ID de bus : 0000:02:00.0)
Création de 3 couches de 1024 unités.
Traceback (dernier appel le plus récent) :
Fichier "translate.py", ligne 322, dans
tf.app.run()
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/python/platform/app.py", ligne 48, en cours
_sys.exit(main(_sys.argv[:1] + flags_passthrough))
Fichier "translate.py", ligne 319, dans main
former()
Fichier "translate.py", ligne 178, dans le train
model = create_model(sess, False)
Fichier "translate.py", ligne 136, dans create_model
dtype=dtype)
Fichier "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", ligne 179, dans __init__
softmax_loss_function=softmax_loss_function)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", ligne 1206, dans model_with_buckets
decoder_inputs[:bucket[1]])
Fichier "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", ligne 178, dans
lambda x, y : seq2seq_f(x, y, Faux),
Fichier "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", ligne 142, dans seq2seq_f
dtype=dtype)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", ligne 848, dans embedding_attention_seq2seq
encoder_cell = copy.deepcopy(cell)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 174, en deepcopy
y = copieur(mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/python/layers/base.py", ligne 476, dans __deepcopy__
setattr(result, k, copy.deepcopy(v, memo))
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 163, en deepcopy
y = copieur(x, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 230, dans _deepcopy_list
y.append(deepcopy(a, memo))
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 190, en deepcopy
y = _reconstruct(x, va, 1, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 334, dans _reconstruct
état = copie profonde (état, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 163, en deepcopy
y = copieur(x, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 257, dans _deepcopy_dict
y[deepcopy(clé, mémo)] = deepcopy(valeur, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 190, en deepcopy
y = _reconstruct(x, va, 1, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 334, dans _reconstruct
état = copie profonde (état, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 163, en deepcopy
y = copieur(x, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 257, dans _deepcopy_dict
y[deepcopy(clé, mémo)] = deepcopy(valeur, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 190, en deepcopy
y = _reconstruct(x, va, 1, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 334, dans _reconstruct
état = copie profonde (état, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 163, en deepcopy
y = copieur(x, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 257, dans _deepcopy_dict
y[deepcopy(clé, mémo)] = deepcopy(valeur, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 190, en deepcopy
y = _reconstruct(x, va, 1, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 334, dans _reconstruct
état = copie profonde (état, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 163, en deepcopy
y = copieur(x, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 257, dans _deepcopy_dict
y[deepcopy(clé, mémo)] = deepcopy(valeur, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 163, en deepcopy
y = copieur(x, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 257, dans _deepcopy_dict
y[deepcopy(clé, mémo)] = deepcopy(valeur, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 163, en deepcopy
y = copieur(x, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 230, dans _deepcopy_list
y.append(deepcopy(a, memo))
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 190, en deepcopy
y = _reconstruct(x, va, 1, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 334, dans _reconstruct
état = copie profonde (état, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 163, en deepcopy
y = copieur(x, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 257, dans _deepcopy_dict
y[deepcopy(clé, mémo)] = deepcopy(valeur, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 190, en deepcopy
y = _reconstruct(x, va, 1, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 334, dans _reconstruct
état = copie profonde (état, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 163, en deepcopy
y = copieur(x, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 257, dans _deepcopy_dict
y[deepcopy(clé, mémo)] = deepcopy(valeur, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 190, en deepcopy
y = _reconstruct(x, va, 1, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 334, dans _reconstruct
état = copie profonde (état, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 163, en deepcopy
y = copieur(x, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 257, dans _deepcopy_dict
y[deepcopy(clé, mémo)] = deepcopy(valeur, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 163, en deepcopy
y = copieur(x, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 230, dans _deepcopy_list
y.append(deepcopy(a, memo))
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 163, en deepcopy
y = copieur(x, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 237, dans _deepcopy_tuple
y.append(deepcopy(a, memo))
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 163, en deepcopy
y = copieur(x, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 257, dans _deepcopy_dict
y[deepcopy(clé, mémo)] = deepcopy(valeur, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 190, en deepcopy
y = _reconstruct(x, va, 1, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 334, dans _reconstruct
état = copie profonde (état, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 163, en deepcopy
y = copieur(x, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 257, dans _deepcopy_dict
y[deepcopy(clé, mémo)] = deepcopy(valeur, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 190, en deepcopy
y = _reconstruct(x, va, 1, mémo)
Fichier "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", ligne 343, dans _reconstruct
y.__dict__.update(état)
AttributeError : l'objet 'NoneType' n'a pas d'attribut 'update'

J'ai également rencontré l'erreur causée par copy.deepcopy(cell) dans embedding_attention_seq2seq() lors de l'exécution self_test() dans le modèle de traduction du didacticiel.
J'ai essayé de changer les codes en seq2seq_f() en Seq2SeqModel comme suit :

    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)

Alors il n'y a plus d'erreur maintenant.
MAIS en tant que débutant, je ne sais pas si les codes ici fonctionnent comme avant et il semble que les changements rendent le modèle plus lent.

Je voudrais informer tout le monde que j'ai rétrogradé le tensorflow à 1.0.0 (tensorflow-GPU) et que cela fonctionne pour moi. Les modèles fonctionnent comme prévu. Je suppose que la version CPU de 1.0.0 devrait fonctionner comme prévu ? Ou?.
Merci :)

Salut les gars, je ne sais pas si ça vous intéresse toujours, mais j'ai trouvé que le problème est lié à l'opération de copie de la cellule passée en paramètre à la fonction embedding_attention_seq2seq . En effet, la même définition de cellule est utilisée à la fois pour le codeur et le décodeur. Je pense que le tutoriel est obsolète car il utilise un modèle seq2seq avec compartimentage contrairement à un seq2seq dynamique. Mais, je colle une fonction modifiée qui fonctionne. La fonction est mise à jour dans le fichier tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py .

Merci,
fabio

```!python
def embedding_attention_seq2seq(encoder_inputs,
entrées_décodeur,
enc_cell,
dec_cell,
num_encoder_symbols,
num_decoder_symbols,
embedding_size,
nombre_têtes=1,
output_projection=Aucun,
feed_previous=Faux,
dtype=Aucun,
portée=Aucune,
initial_state_attention=Faux) :
"" Intégrer le modèle de séquence à séquence avec attention.

Ce modèle embarque d'abord encoder_inputs par un embarquement nouvellement créé (de forme
[num_encoder_symbols x input_size]). Ensuite, il exécute un RNN pour coder
encoder_inputs intégré dans un vecteur d'état. Il conserve les sorties de ce
RNN à chaque étape à utiliser pour attirer l'attention plus tard. Ensuite, il intègre decoder_inputs
par un autre plongement nouvellement créé (de forme [num_decoder_symbols x
taille_entrée]). Ensuite, il exécute le décodeur d'attention, initialisé avec le dernier
l'état de l'encodeur, sur les entrées du décodeur intégré et en s'occupant des sorties de l'encodeur.

Attention : lorsque output_projection vaut None, la taille des vecteurs d'attention
et les variables seront rendues proportionnelles à num_decoder_symbols, peuvent être grandes.

Arguments :
encoder_inputs : une liste de tenseurs 1D int32 de forme [batch_size].
decoder_inputs : une liste de tenseurs 1D int32 de forme [batch_size].
cellule : tf.nn.rnn_cell.RNNCell définissant la fonction et la taille de la cellule.
num_encoder_symbols : nombre entier ; nombre de symboles côté codeur.
num_decoder_symbols : nombre entier ; nombre de symboles côté décodeur.
embedding_size : Entier, la longueur du vecteur d'incorporation pour chaque symbole.
num_heads : nombre de têtes d'attention lues à partir d'attention_states.
output_projection : aucun ou une paire (W, B) de pondérations de projection de sortie et
Les préjugés; W a la forme [output_size x num_decoder_symbols] et B a
forme [num_decoder_symbols] ; si fourni et feed_previous=True, chacun
la sortie précédente alimentée sera d'abord multipliée par W et ajoutée B.
feed_previous : tenseur booléen booléen ou scalaire ; si Vrai, seul le premier
de decoder_inputs seront utilisés (le symbole "GO"), et tous les autres décodeurs
les entrées seront extraites des sorties précédentes (comme dans embedding_rnn_decoder).
Si False, decoder_inputs sont utilisés comme indiqué (le cas de décodeur standard).
dtype : Le dtype de l'état RNN initial (par défaut : tf.float32).
scope : VariableScope pour le sous-graphe créé ; par défaut à
"intégration_attention_seq2seq".
initial_state_attention : si False (valeur par défaut), les attentions initiales sont nulles.
Si True, initialise les attentions à partir de l'état initial et de l'attention
États.

Retour:
Un tuple de la forme (sorties, état), où :
outputs : une liste de la même longueur que decoder_inputs de tenseurs 2D avec
forme [batch_size x num_decoder_symbols] contenant le généré
les sorties.
état : l'état de chaque cellule du décodeur au pas de temps final.
C'est un Tenseur 2D de forme [batch_size x cell.state_size].
"""
avec variable_scope.variable_scope(
portée ou "embedding_attention_seq2seq", dtype=dtype) comme portée :
dtype = portée.dtype
# Encodeur.

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 Merci pour la fonction. Semble vraiment utile. J'ai aussi vu que le tutoriel est obsolète. J'attends toujours une sortie officielle du tutoriel. Il semble que vous ayez utilisé la nouvelle API. Avez-vous un code qui peut être recherché pour commencer à coder sur la nouvelle API ?
Toute aide est bien appréciée. Merci une fois de plus :)

@syw2014 Avez-vous résolu votre problème ?

@w268wang pas encore, toujours en attente d'autres solutions, mais les commentaires de @Miopas peuvent avoir un essai, et j'essaie la solution de @fabiofumarola

ça dit TypeError: embedding_attention_seq2seq() missing 1 required positional argument: 'dec_cell'
après avoir utilisé la mise à jour publiée par @fabiofumarola . Pouvez-vous m'aider s'il vous plaît?

Oui car la mise à jour que je vous ai proposée nécessite de changer le
Fonction embedding_attention_seq2seq. Si vous accédez au fichier source en vous
tensorflow release, vous pouvez modifier vous-même la définition de la méthode.

Le dimanche 2 juillet 2017 à 18h15, sachinh35 [email protected] trote

il dit TypeError : embedding_attention_seq2seq() missing 1 required
argument positionnel : 'dec_cell'

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312500996 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ABepUEc3W8m5CVDQGnCLu4dcJVFwwLDZks5sJ8IOgaJpZM4MWl4f
.

>

Envoyé depuis Gmail Mobile

Oui j'ai fait la même chose. J'ai changé la fonction dans le fichier seq2seq.py dans la version de tensorflow. Je reçois toujours la même erreur. Y a-t-il un autre argument à la fonction ?

Oui, maintenant dans votre code, vous devez spécifier à rnn_cells. Un pour l'encodeur
et un autre pour le décodeur.

Le dim. 2 juil. 2017 à 20h54, fabio fumarola [email protected] a écrit :

Oui

Le dimanche 2 juillet 2017 à 18h50, sachinh35 [email protected] a écrit :

Oui j'ai fait la même chose. J'ai changé la fonction dans le fichier seq2seq.py dans
la libération du tenseur. Je reçois toujours la même erreur. Est-ce qu'il y a un
plus d'argument à la fonction?

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312503106 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ABepUOXTQC_mzLuhcwW0iZRVkLmmr8yIks5sJ8pugaJpZM4MWl4f
.

>

Envoyé depuis Gmail Mobile

Je suis totalement nouveau dans ce domaine. C'est peut-être une question assez basique, mais pourriez-vous dire quel argument passer comme cellule de décodage dans ce code ? J'essaie de développer le seq2seq comme indiqué dans le tutoriel tensorflow en utilisant son propre jeu de données.

`
de __future__ import absolu_import
de la division d'importation __future__
de __future__ importer print_function

importer au hasard

importer numpy en tant que np
from six.moves import xrange # pylint: disable=redefined-builtin
importer tensorflow en tant que tf

importer data_utils

classe Seq2SeqModel (objet):
def __init__(soi,
source_vocab_size,
target_vocab_size,
seaux,
Taille,
nombre_couches,
max_gradient_norm,
taille du lot,
taux d'apprentissage,
learning_rate_decay_factor,
use_lstm=Faux,
nombre_échantillons=512,
forward_only=Faux,
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(self, data, 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`

C'est une bonne question pour le débordement de pile.

Le 3 juillet 2017 à 8h46, "sachinh35" [email protected] a écrit :

Je suis totalement nouveau dans ce domaine. C'est peut-être une question assez basique, mais pourriez-vous
dire quel argument passer comme cellule du décodeur dans ce code ? Je suis
essayer de développer le seq2seq comme indiqué dans le tutoriel tensorflow en utilisant son propre
base de données.
`# Copyright 2015 Les auteurs de TensorFlow. Tous les droits sont réservés.
Sous licence Apache License, Version 2.0 (la "Licence"); tu peux
ne pas utiliser ce fichier sauf en conformité avec la Licence. Vous pouvez obtenir un
copie de la Licence sur http://www.apache.org/licenses/LICENSE-2.0 Sauf si
requis par la loi applicable ou convenu par écrit, le logiciel distribué
sous licence est distribué sur une BASE "TEL QUEL", SANS GARANTIE
OU CONDITIONS DE QUELQUE NATURE QUE CE SOIT, expresses ou implicites. Voir la licence pour
la langue spécifique régissant les autorisations et les limitations en vertu de la

Licence. ================================================= ==========

"""Modèle séquence à séquence avec un mécanisme d'attention."""

de l'import futur absolu_import
de la future division import
de la future importation print_function

importer au hasard

importer numpy en tant que np
from six.moves import xrange # pylint: disable=redefined-builtin
importer tensorflow en tant que tf

importer data_utils

classe Seq2SeqModel (objet):
"""Modèle de séquence à séquence avec attention et pour plusieurs seaux.

Cette classe implémente un réseau de neurones récurrent multicouche comme encodeur,
et un décodeur basé sur l'attention. C'est le même que le modèle décrit dans
cet article : http://arxiv.org/abs/1412.7449 - veuillez y chercher
des détails,
ou dans la bibliothèque seq2seq pour une implémentation complète du modèle.
Cette classe permet également d'utiliser des cellules GRU en plus des cellules LSTM, et
softmax échantillonné pour gérer une grande taille de vocabulaire de sortie. Une couche unique
version de ce modèle, mais avec encodeur bidirectionnel, a été présentée en
http://arxiv.org/abs/1409.0473
et softmax échantillonné est décrit dans la section 3 de l'article suivant.
http://arxiv.org/abs/1412.2007
"""

def init (soi,
source_vocab_size,
target_vocab_size,
seaux,
Taille,
nombre_couches,
max_gradient_norm,
taille du lot,
taux d'apprentissage,
learning_rate_decay_factor,
use_lstm=Faux,
nombre_échantillons=512,
forward_only=Faux,
dtype=tf.float32):
"""Créez le modèle.

Arguments :
source_vocab_size : taille du vocabulaire source.
target_vocab_size : taille du vocabulaire cible.
buckets : une liste de paires (I, O), où I spécifie la longueur d'entrée maximale
qui sera traité dans ce bucket, et O spécifie la sortie maximale
longueur. Instances d'entraînement qui ont des entrées plus longues que I ou des sorties
plus long que O sera poussé vers le seau suivant et complété en conséquence.
Nous supposons que la liste est triée, par exemple, [(2, 4), (8, 16)].
taille : nombre d'unités dans chaque couche du modèle.
num_layers : nombre de couches dans le modèle.
max_gradient_norm : les dégradés seront coupés au maximum de cette norme.
batch_size : la taille des lots utilisés lors de la formation ;
la construction du modèle est indépendante de batch_size, il peut donc être
modifié après l'initialisation si cela convient, par exemple pour le décodage.
learning_rate : taux d'apprentissage pour commencer.
learning_rate_decay_factor : décroît le taux d'apprentissage d'autant en cas de besoin.
use_lstm : si vrai, nous utilisons les cellules LSTM au lieu des cellules GRU.
num_samples : nombre d'échantillons pour le softmax échantillonné.
forward_only : si défini, nous ne construisons pas la passe arrière dans le modèle.
dtype : le type de données à utiliser pour stocker les variables internes.
"""
self.source_vocab_size = source_vocab_size
self.target_vocab_size = target_vocab_size
self.buckets = seaux
self.batch_size = batch_size
self.learning_rate = tf.Variable(
float(learning_rate), entraînable=Faux, 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)

Si nous utilisons softmax échantillonné, nous avons besoin d'une projection de sortie.

output_projection = Aucun
softmax_loss_function = Aucun

Softmax échantillonné n'a de sens que si nous échantillonnons moins que la taille du vocabulaire.

si num_samples > 0 et num_samples < self.target_vocab_size :
w_t = tf.get_variable("proj_w", [self.target_vocab_size, size], dtype=dtype)
w = tf.transposer(w_t)
b = tf.get_variable("proj_b", [self.target_vocab_size], dtype=dtype)
sortie_projection = (w, b)

def sampled_loss(labels, inputs):
labels = tf.reshape(labels, [-1, 1])
# Nous devons calculer le sampled_softmax_loss en utilisant des flottants 32 bits pour
# éviter les instabilités numériques.
local_w_t = tf.cast(w_t, tf.float32)
local_b = tf.cast(b, tf.float32)
local_inputs = tf.cast(inputs, tf.float32)
retour tf.cast(
tf.nn.sampled_softmax_loss(local_w_t, local_b, local_inputs, étiquettes,
num_samples, self.target_vocab_size),
dtype)
softmax_loss_function = sampled_loss

Créez la cellule multicouche interne pour notre RNN.

def single_cell() :
retourner tf.nn.rnn_cell.GRUCell(taille)
si use_lstm :
def single_cell() :
retourner tf.nn.rnn_cell.BasicLSTMCell(taille)
cellule = single_cell()
si num_layers > 1 :
cellule = tf.nn.rnn_cell.MultiRNNCell([single_cell() for _ in range(num_layers)])

La fonction seq2seq : nous utilisons l'intégration pour l'entrée et l'attention.

def seq2seq_f(encoder_inputs, decoder_inputs, do_decode):
return tf.contrib.legacy_seq2seq.embedding_attention_seq2seq(
encoder_inputs,
entrées_décodeur,
cellule,
num_encoder_symbols=source_vocab_size,
num_decoder_symbols=target_vocab_size,
embedding_size=taille,
sortie_projection=sortie_projection,
feed_previous=do_decode,
dtype=dtype)

Flux pour les entrées.

self.encoder_inputs = []
self.decoder_inputs = []
self.target_weights = []
for i in xrange(buckets[-1][0]): # Le dernier bucket est le plus grand.
self.encoder_inputs.append(tf.placeholder(tf.int32, shape=[Aucun],
nom="encodeur{0}".format(i)))
pour i dans xrange(buckets[-1][1] + 1):
self.decoder_inputs.append(tf.placeholder(tf.int32, shape=[Aucun],
nom="décodeur{0}".format(i)))
self.target_weights.append(tf.placeholder(dtype, shape=[None],
nom="poids{0}".format(i)))

Nos cibles sont les entrées du décodeur décalées de un.

cibles = [self.decoder_inputs[i + 1]
pour je dans xrange(len(self.decoder_inputs) - 1)]

Sorties et pertes d'entraînement.

si forward_only :
self.outputs, self.losses = tf.contrib.legacy_seq2seq.model_with_buckets(
self.encoder_inputs, self.decoder_inputs, cibles,
self.target_weights, buckets, lambda x, y : seq2seq_f(x, y, True),
softmax_loss_function=softmax_loss_function)
# Si nous utilisons la projection de sortie, nous devons projeter les sorties pour le décodage.
si output_projection n'est pas None :
pour b dans xrange(len(buckets)):
self.outputs[b] = [
tf.matmul(sortie, projection_sortie[0]) + projection_sortie[1]
pour la sortie dans self.outputs[b]
]
autre:
self.outputs, self.losses = tf.contrib.legacy_seq2seq.model_with_buckets(
self.encoder_inputs, self.decoder_inputs, cibles,
self.target_weights, seaux,
lambda x, y : seq2seq_f(x, y, Faux),
softmax_loss_function=softmax_loss_function)

Gradients et opération de mise à jour SGD pour la formation du modèle.

params = tf.trainable_variables()
sinon forward_only :
self.gradient_norms = []
auto.mises à jour = []
opt = tf.train.GradientDescentOptimizer(self.learning_rate)
pour b dans 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(norme)
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) :
"""Exécuter une étape du modèle en alimentant les entrées données.

Arguments :
session : session tensorflow à utiliser.
encoder_inputs : liste des vecteurs numpy int à alimenter en entrées d'encodeur.
decoder_inputs : liste des vecteurs numpy int à alimenter en entrées du décodeur.
target_weights : liste des vecteurs flottants numpy à alimenter en tant que poids cibles.
bucket_id : quel bucket du modèle utiliser.
forward_only : s'il faut faire le pas en arrière ou seulement en avant.

Retour:
Un triplet composé de gradient norm (ou None si on n'a pas fait marche arrière),
perplexité moyenne, et les sorties.

Augmente :
ValueError : si la longueur de encoder_inputs, decoder_inputs ou
target_weights n'est pas d'accord avec la taille de bucket pour le bucket_id spécifié.
"""

Vérifiez si les tailles correspondent.

encoder_size, decoder_size = self.buckets[bucket_id]
si len(entrées_encodeur) != taille_encodeur :
raise ValueError("La longueur de l'encodeur doit être égale à celle du compartiment,"
" %d != %d." % (len(encoder_inputs), encoder_size))
si len(decoder_inputs) != decoder_size :
raise ValueError("La longueur du décodeur doit être égale à celle du bucket,"
" %d != %d." % (len(decoder_inputs), decoder_size))
si len(target_weights) != decoder_size :
raise ValueError("La longueur des poids doit être égale à celle du bucket,"
" %d != %d." % (len(target_weights), decoder_size))

Alimentation d'entrée : entrées d'encodeur, entrées de décodeur, target_weights, comme fourni.

input_feed = {}
pour l dans xrange(encoder_size):
input_feed[self.encoder_inputs[l].name] = encoder_inputs[l]
pour l dans xrange(decoder_size):
input_feed[self.decoder_inputs[l].name] = decoder_inputs[l]
input_feed[self.target_weights[l].name] = target_weights[l]

Puisque nos cibles sont des entrées de décodeur décalées de un, nous en avons besoin d'une de plus.

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

Flux de sortie : dépend si nous faisons un pas en arrière ou non.

sinon forward_only :
output_feed = [self.updates[bucket_id], # Op de mise à jour qui fait SGD.
self.gradient_norms[bucket_id], # Norme de dégradé.
self.losses[bucket_id]] # Perte pour ce lot.
autre:
output_feed = [self.losses[bucket_id]] # Perte pour ce lot.
for l in xrange(decoder_size): # Logits de sortie.
output_feed.append(self.outputs[bucket_id][l])

outputs = session.run(output_feed, input_feed)
sinon forward_only :
return outputs[1], outputs[2], None # Gradient norm, loss, no outputs.
autre:
return None, outputs[0], outputs[1:] # Pas de norme de gradient, perte, sorties.

def get_batch(self, data, bucket_id):
""" Obtenez un lot aléatoire de données à partir du compartiment spécifié, préparez-vous pour l'étape.

Pour alimenter les données à l'étape (..), il doit s'agir d'une liste de vecteurs majeurs du lot, tandis que
les données ici contiennent des cas majeurs de longueur unique. Donc la logique principale de ceci
fonction est de réindexer les cas de données pour qu'ils soient dans le format approprié pour l'alimentation.

Arguments :
data : un tuple de taille len(self.buckets) dans lequel chaque élément contient
des listes de paires de données d'entrée et de sortie que nous utilisons pour créer un lot.
bucket_id : entier, pour quel compartiment obtenir le lot.

Retour:
Le triple (encoder_inputs, decoder_inputs, target_weights) pour
le lot construit qui a le format approprié pour appeler step(...) plus tard.
"""
encoder_size, decoder_size = self.buckets[bucket_id]
entrées_encodeur, entrées_décodeur = [], []

Obtenez un lot aléatoire d'entrées d'encodeur et de décodeur à partir de données,

remplissez-les si nécessaire, inversez les entrées de l'encodeur et ajoutez GO au décodeur.

pour _ dans xrange(self.batch_size):
entrée_encodeur, entrée_décodeur = random.choice(data[bucket_id])

# Les entrées d'encodeur sont rembourrées puis inversées.
encoder_pad = [data_utils.PAD_ID] * (encoder_size - len(encoder_input))
encoder_inputs.append(liste(inversé(encoder_input + encoder_pad)))

# Les entrées du décodeur reçoivent un symbole "GO" supplémentaire et sont ensuite rembourrées.
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)

Nous créons maintenant des vecteurs majeurs par lots à partir des données sélectionnées ci-dessus.

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

Les entrées d'encodeur par lots sont simplement des entrées d'encodeur réindexées.

pour length_idx dans xrange(encoder_size) :
batch_encoder_inputs.append(
np.array([encoder_inputs[batch_idx][length_idx]
pour batch_idx dans xrange(self.batch_size)], dtype=np.int32))

Les entrées du décodeur par lots sont réindexées decoder_inputs, nous créons des poids.

pour length_idx dans xrange(decoder_size):
batch_decoder_inputs.append(
np.array([decoder_inputs[batch_idx][length_idx]
pour batch_idx dans xrange(self.batch_size)], dtype=np.int32))

# Créez des poids_cibles à 0 pour les cibles qui sont remplies.
batch_weight = np.ones(self.batch_size, dtype=np.float32)
pour batch_idx dans xrange(self.batch_size):
# Nous définissons le poids sur 0 si la cible correspondante est un symbole PAD.
# La cible correspondante est decoder_input décalée de 1 vers l'avant.
si length_idx < decoder_size - 1 :
cible = entrées_décodeur[batch_idx][length_idx + 1]
si length_idx == decoder_size - 1 ou target == data_utils.PAD_ID :
batch_weight[batch_idx] = 0.0
batch_weights.append(batch_weight)
renvoie batch_encoder_inputs, batch_decoder_inputs, batch_weights`

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312679587 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ABtim0l5UMHHtbL1sz7meXserV8NVS7cks5sKQzXgaJpZM4MWl4f
.

D'accord! Merci quand même! :)

@ebrevdo y a-t-il une mise à jour sur la date de sortie du nouveau didacticiel de seq2seq utilisant la nouvelle api ?
Merci. Incroyable travail!.

ouais en attendant le nouveau tutoriel ... ce serait bien de savoir s'il est prévu de le publier prochainement .. @ebrevdo

essayé de prendre du code dans les tests du noyau et de moderniser la recherche de faisceau avec l'ancien seq2seq, mais c'était difficile ...

On espère cette semaine qui arrive !

Le 3 juillet 2017 à 10h16, "prashantserai" [email protected] a écrit :

ouais en attendant le nouveau tutoriel ... ce serait bien de savoir si c'est
prévu de sortir prochainement.. @ebrevdo
https://github.com/ebrevdo

essayé de prendre du code dans les tests du noyau et de moderniser la recherche de faisceau avec
l'héritage seq2seq, mais cela semblait difficile...

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312697274 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ABtim45-HTuQrIRDhphqqHjqkKOKTe53ks5sKSHYgaJpZM4MWl4f
.

Salut les gars,

Toute mise à jour de ce problème, je rencontre la même chose sur tensorflow 1.1-gpu pour mac os x

@tshi1983
J'ai eu le même problème avec tensorflow 1.1-gpu pour ubuntu.
Je passe à TF 1.2. Cela ne fonctionne toujours pas.
Ensuite je change la fonction embedding_attention_seq2seq dans le fichier
tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py
à celui comme @fabiofumarola suggéré ci-dessus.
Maintenant, il commence à s'entraîner. Je n'ai pas encore testé le décodage.

Déplacez le code sur la définition de cellule dans 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(
      ...
      )

Alors "python translate.py --data_dir data/ --train_dir checkpoint/ --size=256 --num_layers=2 --steps_per_checkpoint=50" peut fonctionner.

@huxuanlai ça marche ! Au moins, ça s'entraîne maintenant, merci !

@huxuanlai Fonctionne aussi pour moi.

Je reçois le même AttributeError: 'NoneType' object has no attribute 'update' mais avec tf.contrib.legacy_seq2seq.model_with_buckets . J'utilise tf 1.2.1 (GPU) sur Ubuntu 16.04 lts.

Cela ne semble se produire que lorsque j'ai plus d'un seau.

retraçage complet :

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, votre solution a fonctionné pour moi. Ma version tf est 1.1.0.

J'ai changé de :

    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)  

à:

    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)

Ce n'est toujours pas corrigé, j'ai essayé toutes les solutions possibles, celles mentionnées dans ce fil et stackoverflow, cela ne fonctionne pas avec tensorflow 1.3 ou 1.2 ou 1.1

Je suis face à cette erreur :
TypeError: embedding_attention_seq2seq() missing 1 required positional argument: 'dec_cell'

L'erreur pointe vers cette fonction dans seq2seq_model.py qui est la ligne 142 dans seq2seq_model.py :

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)

Quiconque a rencontré cette erreur et a réussi à résoudre ce problème, veuillez m'aider à corriger ce problème.

ValueError : tentative de réutilisation de RNNCellavec un périmètre variable différent de sa première utilisation. La première utilisation de la cellule était avec la portée 'rnn/multi_rnn_cell/cell_0/gru_cell', cette tentative est avec la portée 'rnn/multi_rnn_cell/cell_1/gru_cell'. Veuillez créer une nouvelle instance de la cellule si vous souhaitez qu'elle utilise un ensemble de pondérations différent. Si vous utilisiez auparavant : MultiRNNCell([GRUCell(...)] * num_layers), remplacez-le par : MultiRNNCell([GRUCell(...) for _ in range(num_layers)]). Si auparavant vous utilisiez la même instance de cellule comme cellule aller et retour d'un RNN bidirectionnel, créez simplement deux instances (une pour aller, une pour inverse). En mai 2017, nous commencerons la transition du comportement de cette cellule pour utiliser les pondérations stockées existantes, le cas échéant, lorsqu'elle est appelée avec scope=None (ce qui peut entraîner une dégradation silencieuse du modèle, donc cette erreur persistera jusque-là.)

le code origine :
depuis tensorflow.contrib importer rnn
entrées = tf.placeholder(dtype=tf.int32, shape=[Aucun, Aucun], name="entrées")
keep_prob = tf.placeholder(dtype=tf.float32, name="keep_prob")
cellule = rnn.GRUCell(10)
cellule = rnn.DropoutWrapper (cellule = cellule, input_keep_prob = keep_prob)
cellule = rnn.MultiRNNCell([cellule pour _ dans la plage(5)], state_is_tuple=True)

sorties, états = tf.nn.dynamic_rnn(cellule=cellule, entrées=look_up, dtype=tf.float32)
Solution:
entrées = tf.placeholder(dtype=tf.int32, shape=[Aucun, Aucun], name="entrées")
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)

Avez-vous ce problème avec les nightlies tf ?

Le 1er octobre 2017 à 8h34, "Baohua Zhou" [email protected] a écrit :

J'ai le même problème lorsque j'utilise tensorflow 1.1 sur un processeur avec ios.

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-333384725 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/ABtimwOv7vf5vvFXBllbZryjCFwmJcU6ks5sn7DxgaJpZM4MWl4f
.

AttributeError : l'objet 'NoneType' n'a pas d'attribut 'update'

en tf=1.3

ValueError : tentative de réutilisation de RNNCellavec un périmètre variable différent de sa première utilisation. La première utilisation de la cellule était avec la portée 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_0/gru_cell', cette tentative est avec la portée 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_1/gru_cell'. Veuillez créer une nouvelle instance de la cellule si vous souhaitez qu'elle utilise un ensemble de pondérations différent. Si vous utilisiez auparavant : MultiRNNCell([GRUCell(...)] * num_layers), remplacez-le par : MultiRNNCell([GRUCell(...) for _ in range(num_layers)]). Si auparavant vous utilisiez la même instance de cellule comme cellule aller et retour d'un RNN bidirectionnel, créez simplement deux instances (une pour aller, une pour inverse). En mai 2017, nous commencerons la transition du comportement de cette cellule pour utiliser les pondérations stockées existantes, le cas échéant, lorsqu'elle est appelée avec scope=None (ce qui peut entraîner une dégradation silencieuse du modèle, donc cette erreur persistera jusque-là.)

Cela fait 14 jours sans activité et l'étiquette awaiting tensorflower a été attribuée. Veuillez mettre à jour le libellé et/ou le statut en conséquence.

Nagging En attente de TensorFlower : Cela fait 14 jours sans activité et l'étiquette awaiting tensorflower a été attribuée. Veuillez mettre à jour le libellé et/ou le statut en conséquence.

La solution consiste à passer à une version plus récente de TF. Ce fil a radicalement divergé de son problème d'origine. Fermeture.

Si vous voulez une solution instantanée, vous pouvez essayer ce que j'ai essayé :

pip install tensorflow==1.0
Le problème est avec la version tenorflow 1.1, cela a fonctionné pour moi.