Recibo el mismo error cuando intento ejecutar el ejemplo de traducción (incluso cuando hago la pequeña autocomprobación) que se puede encontrar aquí: https://github.com/tensorflow/models/tree/master/tutorials/rnn/translate

Me encontré con el mismo problema. Si todos usan la versión compilada en la rama principal, creo que tenemos el mismo problema causado por el compromiso reciente . Como dice el mensaje de confirmación:

Haga que todas las RNNCells en tf.contrib.rnn actúen como tf.layers Layers, pero con una semántica más estricta para no
w:

1. Tras el primer uso de __call__, el ámbito utilizado se almacena en la celda. RNNCell intenta crear pesos en ese ámbito, pero si ya se han establecido algunos, se genera un error, a menos que RNNCell se haya construido con el argumento reuse=True.

2. Un uso posterior de __call__ de la misma instancia de celda debe estar en el mismo ámbito.
   Si no es así, se genera un error.

Desde mi caso, que está ejecutando el tutorial de ptb , la solución es simplemente agregar un parámetro llamado reuse como este en la línea 112:

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

Entonces funciona.

@ebrevdo ¿Podría echarle un vistazo a esto?

El problema se repite para mí cuando uso Windows/GPU compilación 105 en Shakespeare RNN Repo .

Cuando se ejecuta el código con la versión Win 1.0.0/GPU, no hay problema.

Parece que ese repositorio está dirigido a tf 1.0, no a versiones intermedias.

El 8 de marzo de 2017 a las 15:56, "Tom Wanzek" [email protected] escribió:

El problema se repite para mí cuando uso Windows/GPU build 105 en Shakespeare
RNN Repo https://github.com/martin-gorner/tensorflow-rnn-shakespeare .

Cuando se ejecuta el código con la versión Win 1.0.0/GPU, no hay problema.

—
Estás recibiendo esto porque te mencionaron.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285209555 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/ABtim5ansaL1KN51T4nCaqLnqw2QHN4Wks5rj0BBgaJpZM4MWl4f
.

@tongda , estoy usando la versión de lanzamiento de Tensorflow 1.0, trabajando en MacOS en modo CPU. Cambiaré a la rama maestra para ver si funciona agregando el parámetro "reutilizar", gracias.

doncat99: si lo hace, asegúrese de que su código consulte la versión de tensorflow
y levanta una bandera si la versión es más baja que la versión de la rama maestra.
es posible que deba verificar contra:

de las versiones de importación de tensorflow.core
versiones.GIT_VERSION

El miércoles 8 de marzo de 2017 a las 6:58 p. m., doncat99 [email protected] escribió:

@tongda https://github.com/tongda , estoy usando la versión de lanzamiento de
Tensorflow 1.0, trabajando en MacOS en modo CPU. Cambiaré al maestro
branch para ver si funciona agregando el parámetro "reuse", gracias.

—
Estás recibiendo esto porque te mencionaron.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285240438 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/ABtim66cU9e16lgD-2D0QLGcQCiHbV0zks5rj2rbgaJpZM4MWl4f
.

@ebrevdo Entonces, ¿cuáles serían los cambios sugeridos en el RNN de Shakepeare para permitir que funcione con la versión estable intermedia?

Aquí está la sección arquitectónica clave del código, que ahora falla con la compilación n.º 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

Parece que no encuentro ninguna documentación con respecto a un indicador reuse .

Gracias por adelantado.

Usar:

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

Lo que crea un objeto grucell separado para cada capa.

El 10 de marzo de 2017 a las 7:44 a. m., "Tom Wanzek" [email protected] escribió:

@ebrevdo https://github.com/ebrevdo Entonces, ¿cuál sería la sugerencia?
cambios en el RNN de Shakepeare para permitirle trabajar con el intermediario
lanzamiento estable?

Aquí está la sección arquitectónica clave del código, que ahora falla con
construir # 105:

el modelo (ver Preguntas Frecuentes en README.md)

lr = tf.placeholder(tf.float32, name='lr') # tasa de aprendizaje
pkeep = tf.placeholder(tf.float32, name='pkeep') # parámetro de abandono
tamaño de lote = tf.placeholder(tf.int32, nombre='tamaño de lote')

entradas

X = tf.placeholder(tf.uint8, [Ninguno, Ninguno], nombre='X') # [TAMAÑO DEL LOTE, SEQLEN]
Xo = tf.one_hot(X, ALPHASIZE, 1.0, 0.0) # [ BATCHSIZE, SEQLEN, ALPHASIZE ]# resultados esperados = misma secuencia desplazada en 1 ya que estamos tratando de predecir el siguiente carácter
Y_ = tf.placeholder(tf.uint8, [Ninguno, Ninguno], nombre='Y_') # [TAMAÑO DEL LOTE, SEQLEN]
Yo_ = tf.one_hot(Y_, ALPHASIZE, 1.0, 0.0) # [ BATCHSIZE, SEQLEN, ALPHASIZE ]# estado de entrada
Hin = tf.placeholder(tf.float32, [Ninguno, INTERNALSIZE*NLAYERS], name='Hin') # [ BATCHSIZE, INTERNALSIZE * NLAYERS]

usando NLAYERS = 3 capas de celdas GRU, desenrollando SEQLEN = 30 veces # dynamic_rnn infiere SEQLEN del tamaño de las entradas Xo

unacelda = rnn.GRUCell(TAMAÑOINTERNO)
dropcell = rnn.DropoutWrapper(onecell, input_keep_prob=pkeep)
multicell = rnn.MultiRNNCell([dropcell for _ in range(NLAYERS)], state_is_tuple=False)
multicelda = rnn.DropoutWrapper(multicelda, 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 ] # este es el último estado en la secuencia

Parece que no encuentro ninguna documentación con respecto a un indicador de reutilización.

Gracias por adelantado.

—
Estás recibiendo esto porque te mencionaron.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285702372 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/ABtim6MOOCbx3RJEJe8PQBDXGVIXTGPmks5rkW_jgaJpZM4MWl4f
.

No entiendo por qué recibo este error con el modelo de tutorial seq2seq :

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

Fuente

donde se crea la celda con

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

@ebrevdo Gracias por volver a este problema. Desafortunadamente, el cambio sugerido deja las cosas como están, con el error antes mencionado. Dado el comentario anterior sobre el tutorial seq2seq , sospecho que todos estamos en el mismo barco.

¿Estás seguro de que es exactamente el mismo error? Por favor cópielo y péguelo aquí.

Mi error, simplemente pasé por el proceso de cambio al código relevante nuevamente (desde cero) y lo volví a ejecutar como se propuso. De hecho, el error se ha eliminado y el Viejo Bardo está alucinando muy bien ahora 👍

Entonces, gracias, no estoy seguro de dónde me equivoqué ayer, pero claramente fue culpa mía.

Encontré el mismo problema cuando usaba la versión de lanzamiento de Tensorflow 1.0 y trabajaba en MacOS en modo CPU. Incluso si agregaba el parámetro "reutilizar"

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)

tu multicelda se ve mal... deberías estar usando "cell() para _ en
rango(...)"

El jueves 16 de marzo de 2017 a las 8:29 p. m., cuiming [email protected] escribió:

Encontré el mismo problema al usar la versión de lanzamiento de Tensorflow 1.0
y trabajando en MacOS en modo cpu. Incluso si agrega el parámetro "reutilizar"

def celda():
devuelve 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)

—
Estás recibiendo esto porque te mencionaron.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-287257629 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/ABtim3A6JQr8ptRKrdiDW_kgNRIFkHGlks5rmf4WgaJpZM4MWl4f
.

Estaba intentando ejecutar el ejemplo de traducción: python2.7 translate.py --data_dir data/ --train_dir train/ --size=256 --num_layers=2 --steps_per_checkpoint=50

Parece que la forma de usar MultiRNNCell es correcta:
celda = tf.contrib.rnn.MultiRNNCell([single_cell() for _ in range(num_layers)])

Pero tengo el mismo error:
ValueError: intento de reutilizar RNNCellcon un alcance variable diferente al de su primer uso. El primer uso de la celda fue con el alcance 'embedding_attention_seq2seq/embedding_attention_decoder/attention_decoder/multi_rnn_cell/cell_0/gru_cell', este intento es con el alcance 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_0/gru_cell'. Cree una nueva instancia de la celda si desea que use un conjunto diferente de pesos. Si antes estaba usando: MultiRNNCell([GRUCell(...)] * num_layers), cambie a: MultiRNNCell([GRUCell(...) for _ in range(num_layers)]). Si antes estaba usando la misma instancia de celda como celda directa e inversa de un RNN bidireccional, simplemente cree dos instancias (una para adelante, otra para reversa). En mayo de 2017, comenzaremos a hacer la transición del comportamiento de esta celda para usar los pesos almacenados existentes, si los hay, cuando se llame con scope=None (lo que puede conducir a una degradación silenciosa del modelo, por lo que este error permanecerá hasta entonces).

@bowu : ¿tuviste suerte con esto? si aún no lo ha probado, reinstale tensorflow desde la fuente más reciente. hubo algunos cambios en algunos de los archivos core_rnn, entre algunos otros. funciona para mí ahora.

@robmsylvester reinstalé tensorflow desde la fuente más reciente, sigo teniendo el mismo error. Estaba en branch master y la última confirmación es commit 2a4811054a9e6b83e1f5a2705a92aab50e151b13 . ¿Cuál es la última confirmación cuando crea su repositorio?

Hola, estoy usando Tensorflow r1.0 usando GPU construido usando fuente. Estoy tratando de seguir el tutorial de traducción de Seq2Seq sin modificar, pero recibo el mismo error. es decir

ValueError: intento de reutilizar RNNCellcon un alcance variable diferente al de su primer uso. El primer uso de la celda fue con el alcance 'embedding_attention_seq2seq/embedding_attention_decoder/attention_decoder/multi_rnn_cell/cell_0/gru_cell', este intento es con el alcance 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_0/gru_cell'...

La parte relevante del código en mi seq2seq_model.py es:

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

¿Qué puedo hacer para solucionar el problema?

agregar "reuse=tf.get_variable_scope().reuse" a la llamada donde se crea GRUCell no ayuda.

¡Gracias una tonelada!

@prashantserai : vea qué sucede si elimina la línea MultiRNNCell de arriba, haciendo que su red sea solo una capa. ¿Funciona entonces? Podría ser un error en algún lugar de MultiRNNCell. He leído sobre eso en alguna parte recientemente, probablemente en el desbordamiento de pila.

Si implementa el lstm/gru apilado usted mismo, no obtiene este error y puede implementar la misma funcionalidad (en realidad, más, porque puede hacer lo que quiera con arquitecturas bidireccionales, residuos extraños y conexiones de omisión, etc. .)

@robmsylvester El mismo error persistió incluso cuando probé con num_layers=1, que debería omitir esa línea. ¿Alguna otra idea? Gracias por el aporte.

Mmm. Una cosa que me llama la atención es el archivo heredado seq2seq al que se hace referencia:

encoder_cell = copy.deepcopy(cell)

Esta línea parece usarse porque se usa la misma arquitectura tanto en el lado del codificador como en el del decodificador. Hacen una copia de la celda, luego pasan el argumento de la celda a la función de incrustación del decodificador de atención, luego al decodificador de atención en sí.

¿Qué sucede si crea explícitamente la celda del codificador Y la celda del decodificador en su archivo de modelo seq2seq y pasa ambos al archivo de biblioteca heredado, haciendo los pequeños ajustes a las funciones y sus argumentos?

¿ @robmsylvester no debería hacer cambios en los alcances de las celdas? También funciona para los otros dos ejemplos. En mi opinión, esta sería una solución muy fea; debe existir una solución más limpia; tal vez nos estamos perdiendo algo? (También obtuve el mismo error en el tutorial seq2seq, probé todas las soluciones anteriores).

@ iamgroot42 : sí, esa 'solución' es ciertamente muy fea, pero más aún tratando de buscar dónde podría estar un problema. Jugaré con él en unas horas y veré si puedo encontrar algo.

De hecho, copy.deepcopy está ahí porque son funciones heredadas y
no tenemos los recursos para mantenerlos/actualizarlos. Si tu quisieras
introducir un cambio compatible con versiones anteriores que permita al usuario proporcionar una
segunda celda para el paso de decodificación, y si es Ninguno, entonces para recurrir al
copia profunda, entonces estaría feliz de revisar el PR. Tenga en cuenta que sería
tiene que ser un cambio compatible con versiones anteriores.

El martes 4 de abril de 2017 a las 11:38, Rob Sylvester [email protected]
escribió:

@ iamgroot42 https://github.com/iamgroot42 - Sí, esa 'solución' es
es cierto que muy feo, pero más aún tratando de buscar dónde un problema
puede ser. Jugaré con él en unas horas y veré si puedo rastrear algo.
abajo.

—
Estás recibiendo esto porque te mencionaron.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-291593289 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/ABtim1QHTDhOC_zT6cKtmUFPOit5Yjn7ks5rso5CgaJpZM4MWl4f
.

@ebrevdo - Lo pensaré. Tengo un traductor que funciona bastante similar a este pero crea celdas a través de una clase separada que permite insertar capas bidireccionales donde quieras, residuos donde quieras, fusionar entradas con concat vs. sum y algunas otras cosas. Creo que podría migrar mi clase a este tutorial con bastante facilidad usando RNN estáticos. Yo lo haré saber.

@ebrevdo Estoy ejecutando Tensorflow r1.0 (tensorflow-1.0.1-cp36-cp36m-linux_x86_64) en Red Hat y tengo la última versión del tutorial de traducción de Github... ¿Conoces alguna forma de hacer que esto funcione actualmente?

Es lamentable que el tutorial de traducción no funcione con TF 1.0. Deberíamos arreglar eso. @lukaszkaiser , ¿puedes echar un vistazo? Estamos trabajando en un nuevo tutorial, pero aún faltan algunas semanas y requerirá una versión nocturna de TensorFlow (o TF 1.1 o 1.2) para funcionar.

(lukasz; es difícil para mí identificar a partir de los diversos comentarios qué parte del tutorial es defectuosa en TF 1.0. ¿Hay alguna posibilidad de que pueda identificar la línea y pueda ayudar a que funcione?)

@ebrevdo Es este tutorial. El error está en este grupo de líneas. Las celdas pasadas aquí se usan tanto para la fase hacia atrás como hacia adelante del modelo heredado seq2seq, que genera un error debido a que las mismas celdas se usan con diferentes ámbitos.

@ iamgroot42 ¿quieres hacer un PR con los cambios necesarios? Eso sería genial, actualmente no tengo los ciclos para hacerlo yo mismo. ¡Gracias!

Noté que el TF 1.0 funciona bien con la versión más reciente del tutorial de traducción si se compila desde la fuente en branch remotes/origin/r1.0

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

luego compila e instala TensorFlow, funciona bien.

En branch remotes/origin/r1.1 tiene el error "diferente alcance variable".
Modifiqué el código como sugirió @robmsylvester

¿Qué sucede si crea explícitamente la celda del codificador Y la celda del decodificador en su archivo de modelo seq2seq y pasa ambos al archivo de biblioteca heredado, haciendo los pequeños ajustes a las funciones y sus argumentos?

y ahora me funciona.

@oxwsds el Tensorflow que estoy usando es 1.0.1 así que tal vez tenga un error...

Intenté lo que sugirió @robmsylvester en ese momento... y el entrenamiento había comenzado (2 días y 13 horas ahora)... falla durante la decodificación, aunque con el error:

  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)

¿Intentaste decodificar?

@prashantserai No lo sé exactamente, pero lo que conociste parece ser otro problema.

@prashantserai Si falla solo cuando decodifica, ¿quizás tenga algo que ver con el uso de un tamaño de lote de uno? ¿Se sigue entrenando el modelo si reduce el tamaño del lote a uno durante el entrenamiento?

@bowu Mismo error aquí. Mac OX Sierra, TensorFlow 1.1.0-rc1, Python 2.7.10 y Python 3.6.1.

@robmsylvester también se entrenó correctamente con un tamaño de lote de uno, pero falló durante la decodificación de la misma manera o de una manera similar... aquí hay un seguimiento completo... la razón por la que estaba pensando en esto como un error conectado fue por la referencia a seq2seq_f (que era una de las funciones modificadas) (el comentario #prashant de mi código para indicar que una línea modificada es parte del seguimiento)

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 , ¿cambia su opinión sobre la base del seguimiento completo anterior?

@prashantserai Intenté decodificar y funciona bien. Simplemente agrego un argumento encoder_cell a la función tf.contrib.legacy_seq2seq.embedding_attention_seq2seq y en translate/seq2seq_model.py creo la celda y la paso a la función, que se llamó en la función seq2seq_f . ¿Cómo cambiaste tu código?

@oxwsds @robmsylvester @ebrevdo
Finalmente tengo algo que está funcionando ahora (quiero decir, los resultados para mi red de 256 unidades de una sola capa son un poco espantosos, pero eso probablemente se deba a que la red es ultraligera y no ajusté los parámetros EN ABSOLUTO)
Muchísimas gracias a todos...!!!!!

_Estos son mis pensamientos al final de esto:_

@oxwsds comenta que el tutorial (en su forma actual) funciona sin necesidad de modificación cuando Tensorflow se compila desde la rama remotes/origin/r1.0 was TRUE . Aunque, lo triste fue que la versión de Tensorflow que tenía para la cual se necesitaban modificaciones dentro del código de Tensorflow, y la versión en remotes/origin/r1.0 estaban etiquetadas de manera idéntica.

La corrección de @robmsylvester en el comentario (copiado a continuación) FUNCIONÓ para mi versión de Tensorflow donde el Tutorial no funcionó de inmediato (y también debería funcionar para TF 1.1, supongo). Es un poco complicado de implementar, pero podría hacerlo, lo cual es decir algo :-P
El error en mis dos últimos comentarios antes de este se debió a mi error. Como un maniquí, estaba especificando las capas y los parámetros de las unidades ocultas solo durante el entrenamiento, estaba dejando que el código usara los valores predeterminados durante la decodificación. (esta parte del tutorial podría ser una prueba un poco más ficticia: https://www.tensorflow.org/tutorials/seq2seq#lets_run_it)

Mmm. Una cosa que me llama la atención es el archivo heredado seq2seq al que se hace referencia:

encoder_cell = copy.deepcopy(cell)

Esta línea parece usarse porque se usa la misma arquitectura tanto en el lado del codificador como en el del decodificador. Hacen una copia de la celda, luego pasan el argumento de la celda a la función de incrustación del decodificador de atención, luego al decodificador de atención en sí.

¿Qué sucede si crea explícitamente la celda del codificador Y la celda del decodificador en su archivo de modelo seq2seq y pasa ambos al archivo de biblioteca heredado, haciendo los pequeños ajustes a las funciones y sus argumentos?

¡Gracias por la respuesta! Parece que hay algo diferente entre el TF
en pypi y en esa etiqueta? Gunhan, ¿es eso posible?

El lunes 10 de abril de 2017 a las 21:05, prashantserai [email protected]
escribió:

@oxwsds https://github.com/oxwsds @robmsylvester
https://github.com/robmsylvester @ebrevdo https://github.com/ebrevdo
Finalmente tengo algo que está funcionando ahora (es decir, resultados para mi single
la red de unidades de capa 256 es un poco espantosa, pero eso es probablemente solo
porque la red es ultraligera y no ajusté los parámetros EN ABSOLUTO)

Aquí está mi conclusión:

@oxwsds https://github.com/oxwsds comenta que el tutorial (en suforma actual) funciona sin necesidad de modificación cuando Tensorflow estácompilado de la rama remotes/origin/r1.0 era TRUE . la parte triste
aunque siendo esa la version de Tensorflow que tenia para que modificaciones
dentro del código de Tensorflow, y la versión en remotes/origin/r1.0
ambos estaban etiquetados de forma idéntica.

@robmsylvester https://github.com/robmsylvester 's fix en el comentario
(copiado a continuación) FUNCIONÓ para mi versión de Tensorflow donde el Tutorial
no funcionó de inmediato (y también debería funcionar para TF 1.1, supongo). Está
un poco complicado de implementar, pero podría hacerlo, lo cual es decir algo
:-PAGS
El error en mis dos últimos comentarios antes de este se debió a mi error. Me gusta
un maniquí, estaba especificando las capas y los parámetros de unidades ocultas solo
durante el entrenamiento, estaba dejando el código para usar los valores predeterminados durante la decodificación. (estaparte del tutorial podría ser una prueba un poco más ficticia:https://www.tensorflow.org/tutorials/seq2seq#lets_run_ithttps://www.tensorflow.org/tutorials/seq2seq#lets_run_it )

Mmm. Una cosa que me llama la atención es el heredado al que se hace referencia seq2seq
Archivo:

encoder_cell = copy.deepcopy(cell)

Esta línea parece usarse porque se usa la misma arquitectura en ambos
el lado del codificador y del decodificador. Hacen una copia de la celda, luego pasan el
argumento de celda junto con la función de incrustación del decodificador de atención, luego a
el propio decodificador de atención.

¿Qué sucede si crea explícitamente la celda del codificador Y el decodificador?
celda en su archivo de modelo seq2seq y pase ambos a la biblioteca heredada
archivo, haciendo los pequeños ajustes a las funciones y sus argumentos?

—
Estás recibiendo esto porque te mencionaron.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-293143828 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/ABtimxvcfFnbWbpj7aUs3BUjwGEFj6p5ks5ruvvygaJpZM4MWl4f
.

Para obtener información, tuve este problema al intentar apilar celdas LSTM:
Mi código original era:

    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)

Luego, con el siguiente código, la creación del modelo estuvo bien, pero no pude compartir la variable con otro modelo. (por ejemplo, si crea un train_model y un valid_model que se supone que comparten tensores, fallará)

    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)

Así que finalmente usé lstm_creator para que fuera la función como lstm_cell en tensorflow/models/tutorials/rnn/ptb/ptb_word_lm.py#L112 . ahora tengo:

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)

Ahora está completamente funcionando.

tratando de hacer que esto funcione, lo que da como resultado el mismo error:

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

La solución de @pltrdy no me funcionó extrañamente. Me estoy poniendo

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 , ¿usó la función de https://github.com/tensorflow/models/blob/master/tutorials/rnn/ptb/ptb_word_lm.py#L112 que menciono al final de mi publicación (ahora editada para ser más clara) )

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

resolvió mi problema

Logró solucionar este problema instalando una versión anterior de Tensorflow:
pip install -Iv tensorflow==1.0

Estaba recibiendo el error al ejecutar el tutorial seq2seq

Con respecto a lo que dijo @ebrevdo , creo que la solución no es corregir el código seq2seq heredado, sino actualizar el tutorial para usar el paquete contrib.seq2seq , que se mantiene activamente. Es bastante desmoralizador cuando el primer programa tensorflow que ejecutas arroja un montón de errores. Si tengo algo de tiempo esta semana, enviaré un PR.

Estamos trabajando en un nuevo tutorial de seq2seq. Esperábamos lanzarlo a finales de
el mes pasado, pero se están retrasando. Utilizará la nueva API.

El 1 de mayo de 2017 a las 8:07 a. m., "Kyle Teague" [email protected] escribió:

Con respecto a lo que dijo @ebrevdo https://github.com/ebrevdo , creo
la solución no es arreglar el código seq2seq heredado, sino actualizar el
tutorial para usar el paquete contrib.seq2seq en su lugar, que está activamente
mantenido Es bastante desmoralizador cuando el primer programa de tensorflow que
ever run escupe un montón de errores. Si tengo algo de tiempo esta semana, voy a
enviar un PR.

—
Estás recibiendo esto porque te mencionaron.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-298350307 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/ABtim587xZx9Gi4-yXmwccSum8_Trc1oks5r1fUogaJpZM4MWl4f
.

@ebrevdo Me encuentro con el mismo error cuando ejecuto el modelo de secuencia a secuencia en el sitio web de tensorflow1.1. Y he intentado usar el parámetro 'reutilizar' pero fallé. ¿Podría decirme cuándo se lanzará el nuevo tutorial de seq2seq?

Parece que al mismo tiempo que tf 1.2, ya que contaremos con algunos nuevos
características de esa versión.

El 4 de mayo de 2017 a las 21:16, "njuzrs" [email protected] escribió:

@ebrevdo https://github.com/ebrevdo Me encuentro con el mismo error al ejecutar
el modelo de secuencia a secuencia en el sitio web tensorflow1.1. y lo he intentado
para usar el parámetro 'reutilizar' pero falló. ¿Podría decirme cuando el nuevo seq2seq
se publicará el tutorial?

—
Estás recibiendo esto porque te mencionaron.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-299366774 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/ABtim8_kFTM7-SsXQAA-Ar0dfhHMGT0Zks5r2qKngaJpZM4MWl4f
.

@ebrevdo También estoy enfrentando el mismo problema y no puedo avanzar con seq2seq. Sería muy útil si pudieras decirnos cuál es una fecha probable para un nuevo tutorial.
Muchas gracias por tu ayuda.

La instalación usando pip install tensorflow==1.0 (Tensorflow 1.0) funciona para mí (tutorial de traducción).

Tengo la versión 1.1.0-rc2.

¿TF1.2 resolverá este problema? Por favor, ayúdame a seguir entrenando al modelo. TF 1.0 funciona, pero no tiene una API de envoltorio de dispositivo para varias GPU.

Tener el mismo problema con el flujo tensorial 1.1. Todavía trabajando en una solución

Intenté varias cosas, al final pude usar tensorflow 1.1 pero tuve que hacer estos cambios: (basado en Tshzzz arriba)

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

Y añade esto:
celdas=[]
para _ en el rango (NCAPAS):
celda = rnn.DropoutWrapper(tf.contrib.rnn.GRUCell(INTERNALSIZE), input_keep_prob=pkeep)
celdas.append(celda)
multicell = rnn.MultiRNNCell(cells, state_is_tuple=False)

@ebrevdo Felicitaciones, TF 1.2 acaba de ser lanzado. ¿El nuevo tutorial también se lanzó en alguna parte o se lanzará pronto?

Gracias

Planearemos tener un anuncio cuando se publique. Trabajando en ello.

El 19 de mayo de 2017 a las 19:02, "prashantserai" [email protected] escribió:

@ebrevdo https://github.com/ebrevdo Felicitaciones, TF 1.2 acaba de recibir
lanzado: ¿el nuevo tutorial también se lanzó en alguna parte o está siendo
lanzado pronto?

Gracias

—
Estás recibiendo esto porque te mencionaron.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-302844002 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/ABtim0RWDzNCXk-bIjKSyHLvgFxUvq2lks5r7km7gaJpZM4MWl4f
.

Para cualquiera que use tensorflow-gpu==1.1.0 y obtenga este error, cambiar a 1.0.0 a través de pip install tensorflow-gpu==1.0.0 no solucionará el problema, al menos no funcionó para mí.

Me encontré con este problema tanto en mac como en ubuntu y la compilación desde la fuente funcionó en ambas ocasiones. Entonces:
instalación de pip https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.0.0-cp34-cp34m-linux_x86_64.whl

@ajaanbaahu Todavía estoy esperando el nuevo tutorial tf1.2 seq2seq.

Funcionó para mí usando pip install tensorflow==1.0 .

Para tf r1.2, se obtuvo un error de copia profunda. Como se enumeran en el error de modelo de secuencia a secuencia #1050

Como novato, planteo algo de mi opinión.
El siguiente código hará que ocurra este error similar:
(Pieza de mi código)

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)

El volcado de error como el siguiente:

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

Pero después de hacer la revisión, puede funcionar.

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

Ninguna de esas soluciones funcionó para mí con Tensorflow 1.1

Estoy usando seq2seq modelo MultiRNNCell .

Tuve que retroceder a 1.0.1: pip3 install tensorflow==1.0

¿Alguien tiene estos problemas cuando trabaja con legacy_seq2seq.rnn_decoder()?

@oxwsds Como dijiste, cambio la celda de argumentos de entrada de tf.contrib.legacy_seq2seq.embedding_attention_seq2seq a dos celdas diferentes {encoder_cells, decoder_cells}. Finalmente, obtengo el modelo seq2seq trabajado. Después de 73200 setps, obtengo perplejidad 5.54.
Luego ejecuto la parte de decodificación,

¿Quién es el presidente de los Estados Unidos?
Qui est le président des États-Unis ?

Problema resuelto. Gracias.

@doncat99
Parece que copy.deepcopy(cell) en seq2seq.py no tiene efecto.
Entonces cambio la parte relacionada en seq2seq_model.py a

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 , ¿podría compartir su código?

Actualizar a Tensorflow 1.2.0 y generar las celdas en un bucle en lugar de la multiplicación de listas solucionó esto para mí.

Obtuve el error con TF1.2 al ejecutar translate.py, detalles:
nombre: GeForce GTX 1080 Ti
mayor: 6 menor: 1 memoryClockRate (GHz) 1.582
pciBus ID 0000:02:00.0
Memoria total: 10,91 GiB
Memoria libre: 10,76 GiB
2017-06-22 09:15:04.485252: I tensorflow/core/common_runtime/gpu/gpu_device.cc:961] DMA: 0
2017-06-22 09:15:04.485256: I tensorflow/core/common_runtime/gpu/gpu_device.cc:971] 0: Y
2017-06-22 09:15:04.485265: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1030] Crear dispositivo TensorFlow (/gpu:0) -> (dispositivo: 0, nombre: GeForce GTX 1080 Ti, pci ID de autobús: 0000:02:00.0)
Creando 3 capas de 1024 unidades.
Rastreo (llamadas recientes más última):
Archivo "translate.py", línea 322, en
tf.aplicación.ejecutar()
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/python/platform/app.py", línea 48, en ejecución
_sys.exit(main(_sys.argv[:1] + flags_passthrough))
Archivo "translate.py", línea 319, en principal
tren()
Archivo "translate.py", línea 178, en tren
modelo = create_model(sess, Falso)
Archivo "translate.py", línea 136, en create_model
dtipo=dtipo)
Archivo "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", línea 179, en __init__
softmax_loss_function=softmax_loss_function)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", línea 1206, en model_with_buckets
entradas_decodificador[:depósito[1]])
Archivo "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", línea 178, en
lambda x, y: seq2seq_f(x, y, Falso),
Archivo "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", línea 142, en seq2seq_f
dtipo=dtipo)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", línea 848, en embedding_attention_seq2seq
encoder_cell = copy.deepcopy(cell)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 174, en copia profunda
y = copiadora(nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/python/layers/base.py", línea 476, en __deepcopy__
setattr(resultado, k, copy.deepcopy(v, memo))
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 163, en copia profunda
y = copiadora(x, memo)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 230, en _deepcopy_list
y.append(copia profunda(a, memo))
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 190, en copia profunda
y = _reconstruir(x, rv, 1, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 334, en _reconstruct
estado = copia profunda (estado, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 163, en copia profunda
y = copiadora(x, memo)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 257, en _deepcopy_dict
y[copiaprofunda(clave, nota)] = copiaprofunda(valor, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 190, en copia profunda
y = _reconstruir(x, rv, 1, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 334, en _reconstruct
estado = copia profunda (estado, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 163, en copia profunda
y = copiadora(x, memo)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 257, en _deepcopy_dict
y[copiaprofunda(clave, nota)] = copiaprofunda(valor, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 190, en copia profunda
y = _reconstruir(x, rv, 1, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 334, en _reconstruct
estado = copia profunda (estado, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 163, en copia profunda
y = copiadora(x, memo)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 257, en _deepcopy_dict
y[copiaprofunda(clave, nota)] = copiaprofunda(valor, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 190, en copia profunda
y = _reconstruir(x, rv, 1, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 334, en _reconstruct
estado = copia profunda (estado, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 163, en copia profunda
y = copiadora(x, memo)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 257, en _deepcopy_dict
y[copiaprofunda(clave, nota)] = copiaprofunda(valor, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 163, en copia profunda
y = copiadora(x, memo)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 257, en _deepcopy_dict
y[copiaprofunda(clave, nota)] = copiaprofunda(valor, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 163, en copia profunda
y = copiadora(x, memo)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 230, en _deepcopy_list
y.append(copia profunda(a, memo))
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 190, en copia profunda
y = _reconstruir(x, rv, 1, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 334, en _reconstruct
estado = copia profunda (estado, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 163, en copia profunda
y = copiadora(x, memo)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 257, en _deepcopy_dict
y[copiaprofunda(clave, nota)] = copiaprofunda(valor, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 190, en copia profunda
y = _reconstruir(x, rv, 1, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 334, en _reconstruct
estado = copia profunda (estado, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 163, en copia profunda
y = copiadora(x, memo)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 257, en _deepcopy_dict
y[copiaprofunda(clave, nota)] = copiaprofunda(valor, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 190, en copia profunda
y = _reconstruir(x, rv, 1, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 334, en _reconstruct
estado = copia profunda (estado, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 163, en copia profunda
y = copiadora(x, memo)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 257, en _deepcopy_dict
y[copiaprofunda(clave, nota)] = copiaprofunda(valor, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 163, en copia profunda
y = copiadora(x, memo)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 230, en _deepcopy_list
y.append(copia profunda(a, memo))
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 163, en copia profunda
y = copiadora(x, memo)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 237, en _deepcopy_tuple
y.append(copia profunda(a, memo))
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 163, en copia profunda
y = copiadora(x, memo)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 257, en _deepcopy_dict
y[copiaprofunda(clave, nota)] = copiaprofunda(valor, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 190, en copia profunda
y = _reconstruir(x, rv, 1, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 334, en _reconstruct
estado = copia profunda (estado, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 163, en copia profunda
y = copiadora(x, memo)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 257, en _deepcopy_dict
y[copiaprofunda(clave, nota)] = copiaprofunda(valor, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 190, en copia profunda
y = _reconstruir(x, rv, 1, nota)
Archivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", línea 343, en _reconstruct
y.__dict__.update(estado)
AttributeError: el objeto 'NoneType' no tiene atributo 'actualizar'

También encontré el error causado por copy.deepcopy(cell) en embedding_attention_seq2seq() al ejecutar self_test() en el modelo de traducción en el tutorial.
Traté de cambiar los códigos en seq2seq_f() en Seq2SeqModel de la siguiente manera:

    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)

Entonces no hay ningún error ahora.
PERO como novato, no sé si los códigos aquí funcionan como antes y parece que los cambios hacen que el modelo funcione más lento.

Me gustaría informarles a todos que bajé la versión de tensorflow a 1.0.0 (tensorflow-GPU) y me está funcionando. Los modelos están funcionando como se esperaba. ¿Supongo que la versión de CPU de 1.0.0 debería funcionar como se esperaba? ¿O?.
Gracias :)

Hola amigos, no se si aun les interese, pero descubrí que el problema está relacionado con la operación de copiar la celda pasada como parámetro a la función embedding_attention_seq2seq . Esto se debe a que se usa la misma definición de celda tanto para el codificador como para el decodificador. Creo que el tutorial está en desuso ya que usa un modelo seq2seq con depósito en contraste con un seq2seq dinámico. Pero, estoy pegando una función modificada que funciona. La función se actualiza en el archivo tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py .

Gracias,
fabio

```!pitón
def embedding_attention_seq2seq(encoder_inputs,
decodificador_entradas,
enc_cell,
dec_cell,
num_codificador_símbolos,
num_decoder_symbols,
incrustación_tamaño,
número_cabezas=1,
salida_proyección=Ninguno,
feed_previous=Falso,
dtipo=Ninguno,
alcance=Ninguno,
initial_state_attention=Falso):
"""Modelo de secuencia a secuencia incrustado con atención.

Este modelo primero incrusta encoder_inputs mediante una incrustación recién creada (de forma
[num_encoder_symbols x input_size]). Luego ejecuta un RNN para codificar
codificador_entradas incrustadas en un vector de estado. Mantiene las salidas de este
RNN en cada paso para usar para atención posterior. A continuación, incorpora decoder_inputs
por otra incrustación recién creada (de forma [num_decoder_symbols x
tamaño_de_entrada]). Luego ejecuta el decodificador de atención, inicializado con el último
estado del codificador, en decoder_inputs incorporados y atendiendo a las salidas del codificador.

Advertencia: cuando output_projection es Ninguno, el tamaño de los vectores de atención
y las variables se harán proporcionales a num_decoder_symbols, pueden ser grandes.

Argumentos:
encoder_inputs: una lista de tensores 1D int32 de forma [batch_size].
decoder_inputs: una lista de tensores 1D int32 de forma [batch_size].
celda: tf.nn.rnn_cell.RNNCell que define la función y el tamaño de la celda.
num_encoder_symbols: Entero; número de símbolos en el lado del codificador.
num_decoder_symbols: Entero; número de símbolos en el lado del decodificador.
embedding_size: Entero, la longitud del vector de incrustación para cada símbolo.
num_heads: número de cabezas de atención que leen de los estados de atención.
output_projection: Ninguno o un par (W, B) de pesos de proyección de salida y
sesgos; W tiene forma [output_size x num_decoder_symbols] y B tiene
forma [num_decoder_symbols]; si se proporciona y feed_previous=True, cada
La salida anterior alimentada primero se multiplicará por W y se sumará B.
feed_previous: Tensor booleano booleano o escalar; si es cierto, solo el primero
de decoder_inputs (el símbolo "GO"), y todos los demás decodificadores
las entradas se tomarán de las salidas anteriores (como en embedding_rnn_decoder).
Si es False, las entradas_decodificador se usan tal como se dan (el caso estándar del decodificador).
dtype: El dtype del estado RNN inicial (predeterminado: tf.float32).
alcance: VariableScope para el subgrafo creado; por defecto a
"incrustación_atención_seq2seq".
initial_state_attention: si es falso (predeterminado), las atenciones iniciales son cero.
Si es Verdadero, inicializa las atenciones desde el estado inicial y la atención
estados

Devoluciones:
Una tupla de la forma (salidas, estado), donde:
salidas: una lista de la misma longitud que decoder_inputs de tensores 2D con
forma [batch_size x num_decoder_symbols] que contiene el generado
salidas.
estado: El estado de cada celda del decodificador en el paso de tiempo final.
Es un tensor 2D de forma [batch_size x cell.state_size].
"""
with variable_scope.variable_scope(
alcance o "embedding_attention_seq2seq", dtype=dtype) como alcance:
tipod = ámbito.tipod
# Codificador.

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 Gracias por la función. Parece realmente útil. También vi que el tutorial está en desuso. Todavía estoy esperando el lanzamiento oficial del tutorial. Parece que has usado la nueva API. ¿Tiene algún código que se pueda buscar para comenzar a codificar en la nueva API?
Cualquier ayuda es bien apreciada. Gracias otra vez :)

@ syw2014 ¿Solucionaste tu problema?

@w268wang todavía no, sigo esperando otras soluciones, pero los comentarios de @Miopas pueden intentarlo, y estoy probando la solución de @fabiofumarola

dice TypeError: embedding_attention_seq2seq() missing 1 required positional argument: 'dec_cell'
después de usar la actualización que publicó @fabiofumarola . ¿Pueden por favor ayudarme?

Sí, porque la actualización que he propuesto requiere que cambie el
Función embedding_attention_seq2seq. Si vas al archivo fuente en ti
tensorflow release puede cambiar la definición del método usted mismo.

El domingo 2 de julio de 2017 a las 18:15, sachinh35 [email protected] trote

dice TypeError: embedding_attention_seq2seq() falta 1 requerido
argumento posicional: 'dec_cell'

—
Estás recibiendo esto porque te mencionaron.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312500996 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/ABepUEc3W8m5CVDQGnCLu4dcJVFwwLDZks5sJ8IOgaJpZM4MWl4f
.

>

Enviado desde Gmail móvil

Sí, hice lo mismo. Cambié la función en el archivo seq2seq.py en el lanzamiento de tensorflow. Todavía estoy recibiendo el mismo error. ¿Hay un argumento más para la función?

Sí, ahora en su código debe especificar rnn_cells. Uno para el codificador
y otro para el decodificador.

El domingo 2 de julio de 2017 a las 20:54, fabio fumarola [email protected] escribió:

sí

El domingo 2 de julio de 2017 a las 18:50, sachinh35 [email protected] escribió:

Sí, hice lo mismo. Cambié la función en el archivo seq2seq.py en
la liberación de tensorflow. Todavía estoy recibiendo el mismo error. hay uno
más argumento a la función?

—
Estás recibiendo esto porque te mencionaron.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312503106 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/ABepUOXTQC_mzLuhcwW0iZRVkLmmr8yIks5sJ8pugaJpZM4MWl4f
.

>

Enviado desde Gmail móvil

Soy totalmente nuevo en esto. Tal vez esta sea una pregunta bastante básica, pero ¿podría decir qué argumento se debe pasar como la celda del decodificador en este código? Estoy tratando de desarrollar el seq2seq como se muestra en el tutorial de tensorflow usando un conjunto de datos propio.

`
de __futuro__ importar importación_absoluta
de la división de importación __future__
de __futuro__ importar print_function

importar al azar

importar numpy como np
de six.moves import xrange # pylint: disabled=redefined-builtin
importar tensorflow como tf

importar data_utils

clase Seq2SeqModel(objeto):
def __init__(auto,
source_vocab_size,
target_vocab_size,
cubos,
Talla,
número_capas,
max_gradient_norm,
tamaño del lote,
tasa de aprendizaje,
tasa_de_aprendizaje_factor_decaimiento,
use_lstm=Falso,
núm_muestras=512,
forward_only=Falso,
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, codificador_entradas, decodificador_entradas, target_weights,
id_cubo, solo_adelante):

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

Esta es una buena pregunta para el desbordamiento de pila.

El 3 de julio de 2017 a las 8:46 a. m., "sachinh35" [email protected] escribió:

Soy totalmente nuevo en esto. Tal vez esta sea una pregunta bastante básica, pero ¿podría
decir qué argumento se pasará como la celda del decodificador en este código? yo soy
tratando de desarrollar el seq2seq como se muestra en el tutorial de tensorflow usando su propio
conjunto de datos
`# Copyright 2015 Los autores de TensorFlow. Reservados todos los derechos.
Con licencia de Apache License, Versión 2.0 (la "Licencia"); puedes
No use este archivo excepto de conformidad con la Licencia. Puede obtener un
copia de la Licencia en http://www.apache.org/licenses/LICENSE-2.0 A menos que
requerido por la ley aplicable o acordado por escrito, el software distribuido
bajo la Licencia se distribuye "TAL CUAL", SIN GARANTÍAS
O CONDICIONES DE CUALQUIER TIPO, ya sean expresas o implícitas. Consulte la Licencia de
el lenguaje específico que rige los permisos y limitaciones bajo el

Licencia. ================================================== ==========

"""Modelo de secuencia a secuencia con un mecanismo de atención."""

de importación futura importación_absoluta
de la futura división de importación
de importación futura print_function

importar al azar

importar numpy como np
de six.moves import xrange # pylint: disabled=redefined-builtin
importar tensorflow como tf

importar data_utils

clase Seq2SeqModel(objeto):
"""Modelo de secuencia a secuencia con atención y para varios cubos.

Esta clase implementa una red neuronal recurrente multicapa como codificador,
y un decodificador basado en la atención. Este es el mismo que el modelo descrito en
este documento: http://arxiv.org/abs/1412.7449 - busque allí
detalles,
o en la biblioteca seq2seq para la implementación completa del modelo.
Esta clase también permite utilizar celdas GRU además de celdas LSTM, y
softmax muestreado para manejar un gran tamaño de vocabulario de salida. Una sola capa
versión de este modelo, pero con codificador bidireccional, se presentó en
http://arxiv.org/abs/1409.0473
y softmax muestreado se describe en la Sección 3 del siguiente documento.
http://arxiv.org/abs/1412.2007
"""

def init (auto,
source_vocab_size,
target_vocab_size,
cubos,
Talla,
número_capas,
max_gradient_norm,
tamaño del lote,
tasa de aprendizaje,
tasa_de_aprendizaje_factor_decaimiento,
use_lstm=Falso,
núm_muestras=512,
forward_only=Falso,
dtype=tf.float32):
"""Crear el modelo.

Argumentos:
source_vocab_size: tamaño del vocabulario fuente.
target_vocab_size: tamaño del vocabulario objetivo.
cubos: una lista de pares (I, O), donde I especifica la longitud máxima de entrada
que se procesará en ese depósito, y O especifica la salida máxima
longitud. Instancias de entrenamiento que tienen entradas más largas que I o salidas
más largo que O se empujará al siguiente cubo y se rellenará en consecuencia.
Suponemos que la lista está ordenada, por ejemplo, [(2, 4), (8, 16)].
tamaño: número de unidades en cada capa del modelo.
num_layers: número de capas en el modelo.
max_gradient_norm: los gradientes se recortarán al máximo de esta norma.
batch_size: el tamaño de los lotes utilizados durante el entrenamiento;
la construcción del modelo es independiente de lote_tamaño, por lo que puede ser
cambiado después de la inicialización si esto es conveniente, por ejemplo, para decodificar.
learning_rate: tasa de aprendizaje para empezar.
learning_rate_decay_factor: disminuye la tasa de aprendizaje tanto como sea necesario.
use_lstm: si es verdadero, usamos celdas LSTM en lugar de celdas GRU.
num_samples: número de muestras para softmax muestreado.
forward_only: si se establece, no construimos el paso hacia atrás en el modelo.
dtype: el tipo de datos a usar para almacenar variables internas.
"""
self.source_vocab_size = source_vocab_size
self.target_vocab_size = target_vocab_size
self.cubetas = cubetas
self.batch_size = lote_tamaño
self.learning_rate = tf.Variable(
float(aprendizaje_tasa), entrenable=Falso, dtype=dtype)
self.learning_rate_decay_op = self.learning_rate.assign(
self.learning_rate * learning_rate_decay_factor)
self.global_step = tf.Variable(0, entrenable=Falso)

Si usamos softmax muestreado, necesitamos una proyección de salida.

salida_proyección = Ninguno
softmax_loss_function = Ninguno

Softmax muestreado solo tiene sentido si muestreamos menos que el tamaño del vocabulario.

si num_samples > 0 y num_samples < self.target_vocab_size:
w_t = tf.get_variable("proj_w", [self.target_vocab_size, size], dtype=dtype)
w = tf.transponer(w_t)
b = tf.get_variable("proy_b", [self.target_vocab_size], dtype=dtype)
salida_proyección = (w, b)

def sampled_loss(etiquetas, entradas):
etiquetas = tf.reshape(etiquetas, [-1, 1])
# Necesitamos calcular sampled_softmax_loss usando flotantes de 32 bits para
# evitar inestabilidades numéricas.
local_w_t = tf.cast(w_t, tf.float32)
local_b = tf.cast(b, tf.float32)
entradas_locales = tf.cast(entradas, tf.float32)
volver tf. cast (
tf.nn.sampled_softmax_loss(local_w_t, local_b, local_inputs, etiquetas,
num_muestras, self.target_vocab_size),
tipo de d)
softmax_loss_function = sampled_loss

Cree la celda interna de múltiples capas para nuestro RNN.

def sola_celda():
devuelve tf.nn.rnn_cell.GRUCell(tamaño)
si use_lstm:
def sola_celda():
devuelve tf.nn.rnn_cell.BasicLSTMCell(tamaño)
celda = celda_única()
si num_layers > 1:
celda = tf.nn.rnn_cell.MultiRNNCell([single_cell() for _ in range(num_layers)])

La función seq2seq: usamos la incrustación para la entrada y la atención.

def seq2seq_f(encoder_inputs, decoder_inputs, do_decode):
devuelve tf.contrib.legacy_seq2seq.embedding_attention_seq2seq(
codificador_entradas,
decodificador_entradas,
celda,
num_encoder_symbols=source_vocab_size,
num_decoder_symbols=target_vocab_size,
incrustar_tamaño=tamaño,
salida_proyección=salida_proyección,
feed_previous=do_decode,
dtipo=dtipo)

Feeds para entradas.

self.encoder_inputs = []
self.decoder_inputs = []
self.target_weights = []
for i in xrange(cubetas[-1][0]): # La última cubeta es la más grande.
self.encoder_inputs.append(tf.placeholder(tf.int32, forma=[Ninguno],
nombre="codificador{0}".formato(i)))
para i en xrange(cubetas[-1][1] + 1):
self.decoder_inputs.append(tf.placeholder(tf.int32, forma=[Ninguno],
nombre="decodificador{0}".formato(i)))
self.target_weights.append(tf.placeholder(dtype, shape=[Ninguno],
nombre="peso{0}".formato(i)))

Nuestros objetivos son las entradas del decodificador desplazadas en uno.

objetivos = [self.decoder_inputs[i + 1]
para i en xrange(len(self.decoder_inputs) - 1)]

Salidas y pérdidas de formación.

si solo_reenviar:
self.outputs, self.losses = tf.contrib.legacy_seq2seq.model_with_buckets(
self.encoder_inputs, self.decoder_inputs, objetivos,
self.target_weights, cubos, lambda x, y: seq2seq_f(x, y, True),
softmax_loss_function=softmax_loss_function)
# Si usamos proyección de salida, necesitamos proyectar salidas para decodificación.
si output_projection no es Ninguno:
para b en xrange(len(cubetas)):
self.outputs[b] = [
tf.matmul(salida, salida_proyección[0]) + salida_proyección[1]
para salida en self.outputs[b]
]
demás:
self.outputs, self.losses = tf.contrib.legacy_seq2seq.model_with_buckets(
self.encoder_inputs, self.decoder_inputs, objetivos,
self.target_weights, cubetas,
lambda x, y: seq2seq_f(x, y, Falso),
softmax_loss_function=softmax_loss_function)

Operación de actualización de gradientes y SGD para entrenar el modelo.

parámetros = tf.trainable_variables()
si no solo reenviar:
self.gradient_norms = []
auto.actualizaciones = []
opt = tf.train.GradientDescentOptimizer(self.learning_rate)
para b en xrange(len(cubetas)):
gradientes = tf.gradients(self.losses[b], params)
degradados_recortados, norma = tf.clip_by_global_norm(gradientes,
max_gradient_norm)
self.gradient_norms.append(norma)
self.updates.append(opt.apply_gradients(
zip(gradientes_recortados, parámetros), paso_global=self.paso_global))

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

def step(self, session, codificador_entradas, decodificador_entradas, target_weights,
id_cubo, solo_adelante):
"""Ejecutar un paso del modelo alimentando las entradas dadas.

Argumentos:
session: sesión de tensorflow a usar.
encoder_inputs: lista de vectores numpy int para alimentar como entradas de codificador.
decoder_inputs: lista de vectores numpy int para alimentar como entradas del decodificador.
target_weights: lista de vectores flotantes numpy para alimentar como pesos objetivo.
bucket_id: qué depósito del modelo usar.
forward_only: si hacer el paso hacia atrás o solo hacia adelante.

Devoluciones:
Un triple que consiste en norma de gradiente (o Ninguno si no lo hicimos al revés),
la perplejidad media, y las salidas.

Aumentos:
ValueError: si la longitud de encoder_inputs, decoder_inputs o
target_weights no está de acuerdo con el tamaño del depósito para el ID_de depósito especificado.
"""

Compruebe si los tamaños coinciden.

codificador_tamaño, decodificador_tamaño = self.cubetas[bucket_id]
if len(entradas_codificador) != tamaño_codificador:
raise ValueError("La longitud del codificador debe ser igual a la del cubo,"
" %d != %d." % (len(entradas_codificador), tamaño_codificador))
if len(entradas_decodificador) != tamaño_decodificador:
raise ValueError("La longitud del decodificador debe ser igual a la del cubo,"
" %d != %d." % (len(entradas_decodificador), tamaño_decodificador))
if len(target_weights) != decoder_size:
raise ValueError("La longitud de los pesos debe ser igual a la del cubo,"
" %d != %d." % (len(pesos_objetivo), tamaño_decodificador))

Fuente de entrada: entradas del codificador, entradas del decodificador, target_weights, según se proporcione.

input_feed = {}
para l en xrange (tamaño_codificador):
input_feed[self.encoder_inputs[l].name] = encoder_inputs[l]
para l en xrange (tamaño_decodificador):
input_feed[self.decoder_inputs[l].name] = decoder_inputs[l]
input_feed[self.target_weights[l].name] = target_weights[l]

Dado que nuestros objetivos son entradas del decodificador desplazadas en uno, necesitamos una más.

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

Feed de salida: depende de si damos un paso atrás o no.

si no solo reenviar:
output_feed = [self.updates[bucket_id], # Update Op que hace SGD.
self.gradient_norms[bucket_id], # Norma de gradiente.
self.losses[bucket_id]] # Pérdida para este lote.
demás:
output_feed = [self.losses[bucket_id]] # Pérdida para este lote.
for l in xrange(decoder_size): # Logitos de salida.
output_feed.append(self.outputs[bucket_id][l])

salidas = session.run(output_feed, input_feed)
si no solo reenviar:
return outputs[1], outputs[2], None # Norma de gradiente, pérdida, sin salidas.
demás:
return Ninguno, salidas[0], salidas[1:] # Sin norma de gradiente, pérdida, salidas.

def get_batch(self, data, bucket_id):
"""Obtenga un lote aleatorio de datos del depósito especificado, prepárese para el paso.

Para alimentar datos en el paso (...) debe ser una lista de vectores de lotes principales, mientras que
los datos aquí contienen casos principales de longitud única. Así que la lógica principal de esto
La función es volver a indexar los casos de datos para que estén en el formato adecuado para la alimentación.

Argumentos:
data: una tupla de tamaño len(self.buckets) en la que cada elemento contiene
listas de pares de datos de entrada y salida que usamos para crear un lote.
bucket_id: entero, para qué depósito obtener el lote.

Devoluciones:
El triple (encoder_inputs, decoder_inputs, target_weights) para
el lote construido que tiene el formato adecuado para llamar al paso (...) más adelante.
"""
codificador_tamaño, decodificador_tamaño = self.cubetas[bucket_id]
codificador_entradas, decodificador_entradas = [], []

Obtenga un lote aleatorio de entradas de codificador y decodificador de datos,

rellénelos si es necesario, invierta las entradas del codificador y agregue GO al decodificador.

para _ en xrange(self.batch_size):
codificador_entrada, decodificador_entrada = random.choice(data[bucket_id])

# Las entradas del codificador se rellenan y luego se invierten.
encoder_pad = [data_utils.PAD_ID] * (encoder_size - len(encoder_input))
encoder_inputs.append(lista(invertida(encoder_input + encoder_pad)))

# Las entradas del decodificador obtienen un símbolo "GO" adicional y luego se rellenan.
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)

Ahora creamos vectores de lotes principales a partir de los datos seleccionados anteriormente.

entradas_codificador_lote, entradas_decodificador_lote, pesos_lote = [], [], []

Las entradas del codificador por lotes son solo entradas_codificadores reindexadas.

para length_idx en xrange (encoder_size):
lote_codificador_entradas.append(
np.array([encoder_inputs[batch_idx][length_idx]
para lote_idx en xrange(self.batch_size)], dtype=np.int32))

Las entradas del decodificador por lotes son decoder_inputs reindexadas, creamos pesos.

para length_idx en xrange(decoder_size):
lote_decodificador_entradas.append(
np.array([decoder_inputs[batch_idx][length_idx]
para lote_idx en xrange(self.batch_size)], dtype=np.int32))

# Cree target_weights para que sean 0 para los objetivos que se están rellenando.
lote_peso = np.ones(self.batch_size, dtype=np.float32)
para lote_idx en xrange(self.batch_size):
# Establecemos el peso en 0 si el objetivo correspondiente es un símbolo PAD.
# El objetivo correspondiente es decoder_input desplazado 1 hacia adelante.
si longitud_idx < tamaño_decodificador - 1:
objetivo = decoder_inputs[batch_idx][length_idx + 1]
si length_idx == decoder_size - 1 o target == data_utils.PAD_ID:
lote_peso[lote_idx] = 0.0
lotes_pesos.append(lote_pesos)
devolver lote_encoder_inputs, lote_decodificador_inputs, lote_pesos`

—
Estás recibiendo esto porque te mencionaron.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312679587 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/ABtim0l5UMHHtbL1sz7meXserV8NVS7cks5sKQzXgaJpZM4MWl4f
.

¡Okey! gracias! :)

@ebrevdo , ¿hay alguna actualización sobre cuándo saldrá el nuevo tutorial de seq2seq usando una nueva API?
Gracias. ¡Increíble trabajo!.

sí, esperando el nuevo tutorial... sería genial saber si está planeado lanzarlo pronto... @ebrevdo

Traté de tomar el código en las pruebas del núcleo y actualizar la búsqueda de haz con el seq2seq heredado, pero fue un desafío...

¡Esperamos para esta próxima semana!

El 3 de julio de 2017 a las 10:16 a. m., "prashantserai" [email protected] escribió:

sí esperando el nuevo tutorial... sería genial saber si es
planeado para ser lanzado pronto.. @ebrevdo
https://github.com/ebrevdo

trató de tomar código en las pruebas del núcleo y actualizar la búsqueda de haz con
el legado seq2seq, pero parecía desafiante...

—
Estás recibiendo esto porque te mencionaron.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312697274 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/ABtim45-HTuQrIRDhphqqHjqkKOKTe53ks5sKSHYgaJpZM4MWl4f
.

Hola tios,

Cualquier actualización de este problema, estoy experimentando lo mismo en tensorflow 1.1-gpu para mac os x

@tshi1983
Tengo el mismo problema con tensorflow 1.1-gpu para ubuntu.
Actualicé a tf 1.2. Todavía no funciona.
Luego cambio la función embedding_attention_seq2seq en el archivo
tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py
al que @fabiofumarola sugirió arriba.
Ahora empieza a entrenar. Todavía no he probado la decodificación.

Mueva el código en la definición de celda a 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(
      ...
      )

Entonces "python translate.py --data_dir data/ --train_dir checkpoint/ --size=256 --num_layers=2 --steps_per_checkpoint=50" puede funcionar.

@huxuanlai funciona! Al menos ahora está entrenando, ¡gracias!

@huxuanlai También funciona para mí.

Estoy recibiendo el mismo AttributeError: 'NoneType' object has no attribute 'update' pero con tf.contrib.legacy_seq2seq.model_with_buckets . Estoy ejecutando tf 1.2.1 (GPU) en ubuntu 16.04 lts.

Esto solo parece ocurrir cuando tengo más de 1 balde.

rastreo completo:

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
Gracias, tu solución funcionó para mí. Mi versión de tf es 1.1.0.

Cambié 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)  

a:

    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)

Esto todavía no está solucionado, probé todas las soluciones posibles, las mencionadas en este hilo y stackoverflow, no funciona con tensorflow 1.3 o 1.2 o 1.1

Estoy enfrentando este error:
TypeError: embedding_attention_seq2seq() missing 1 required positional argument: 'dec_cell'

El error apunta a esta función en seq2seq_model.py que es la línea 142 en 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)

Cualquiera que haya encontrado este error y haya logrado resolverlo, por favor ayúdame a corregir este problema.

ValueError: intento de reutilizar RNNCellcon un alcance variable diferente al de su primer uso. El primer uso de la celda fue con el alcance 'rnn/multi_rnn_cell/cell_0/gru_cell', este intento es con el alcance 'rnn/multi_rnn_cell/cell_1/gru_cell'. Cree una nueva instancia de la celda si desea que use un conjunto diferente de pesos. Si antes estaba usando: MultiRNNCell([GRUCell(...)] * num_layers), cambie a: MultiRNNCell([GRUCell(...) for _ in range(num_layers)]). Si antes estaba usando la misma instancia de celda como celda directa e inversa de un RNN bidireccional, simplemente cree dos instancias (una para adelante, otra para reversa). En mayo de 2017, comenzaremos a hacer la transición del comportamiento de esta celda para usar los pesos almacenados existentes, si los hay, cuando se llame con scope=None (lo que puede conducir a una degradación silenciosa del modelo, por lo que este error permanecerá hasta entonces).

el código de origen:
desde tensorflow.contrib importar rnn
entradas = tf.placeholder(dtype=tf.int32, forma=[Ninguna, Ninguna], nombre="entradas")
keep_prob = tf.placeholder(dtype=tf.float32, name="keep_prob")
celda = rnn.GRUCell(10)
celda = rnn.DropoutWrapper(celda=celda, input_keep_prob=keep_prob)
celda = rnn.MultiRNNCell([celda para _ en rango(5)], state_is_tuple=True)

salidas, estados = tf.nn.dynamic_rnn(cell=cell, inputs=look_up, dtype=tf.float32)
solución:
entradas = tf.placeholder(dtype=tf.int32, forma=[Ninguna, Ninguna], nombre="entradas")
keep_prob = tf.placeholder(dtype=tf.float32, name="keep_prob")
celda = rnn.MultiRNNCell([rnn.DropoutWrapper(rnn.GRUCell(10), input_keep_prob=keep_prob) for _ in range(5)] , state_is_tuple=True)

¿Tienes este problema con los tf nightlies?

El 1 de octubre de 2017 a las 8:34 a. m., "Baohua Zhou" [email protected] escribió:

Tengo el mismo problema cuando uso tensorflow 1.1 en la CPU con ios.

—
Estás recibiendo esto porque te mencionaron.
Responda a este correo electrónico directamente, véalo en GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-333384725 ,
o silenciar el hilo
https://github.com/notifications/unsubscribe-auth/ABtimwOv7vf5vvFXBllbZryjCFwmJcU6ks5sn7DxgaJpZM4MWl4f
.

AttributeError: el objeto 'NoneType' no tiene atributo 'actualizar'

en tf=1.3

ValueError: intento de reutilizar RNNCellcon un alcance variable diferente al de su primer uso. El primer uso de la celda fue con el alcance 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_0/gru_cell', este intento es con el alcance 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_1/gru_cell'. Cree una nueva instancia de la celda si desea que use un conjunto diferente de pesos. Si antes estaba usando: MultiRNNCell([GRUCell(...)] * num_layers), cambie a: MultiRNNCell([GRUCell(...) for _ in range(num_layers)]). Si antes estaba usando la misma instancia de celda como celda directa e inversa de un RNN bidireccional, simplemente cree dos instancias (una para adelante, otra para reversa). En mayo de 2017, comenzaremos a hacer la transición del comportamiento de esta celda para usar los pesos almacenados existentes, si los hay, cuando se llame con scope=None (lo que puede conducir a una degradación silenciosa del modelo, por lo que este error permanecerá hasta entonces).

Han pasado 14 días sin actividad y se asignó la etiqueta awaiting tensorflower . Actualice la etiqueta y/o el estado en consecuencia.

Nagging Awaiting TensorFlower: han pasado 14 días sin actividad y se asignó la etiqueta awaiting tensorflower . Actualice la etiqueta y/o el estado en consecuencia.

La solución es pasar a una versión más nueva de TF. Este hilo se ha desviado drásticamente de su edición original. Clausura.

Si desea una solución instantánea, puede probar lo que probé:

pip install tensorflow==1.0
El problema es con la versión tenorflow 1.1, funcionó para mí.