Tensorflow: ValueError: Tente reutilizar o RNNCell com um escopo de variável diferente do seu primeiro uso.

Criado em 8 mar. 2017  ·  102Comentários  ·  Fonte: tensorflow/tensorflow

Não tenho certeza se sou o primeiro que encontrou o seguinte erro:

ValueError: Tentativa de reutilizar RNNCellcom um escopo de variável diferente do seu primeiro uso. O primeiro uso da célula foi com o escopo 'rnn/multi_rnn_cell/cell_0/basic_lstm_cell', esta tentativa é com o escopo 'rnn/multi_rnn_cell/cell_1/basic_lstm_cell'. Crie uma nova instância da célula se desejar que ela use um conjunto diferente de pesos. Se antes você estava usando: MultiRNNCell([BasicLSTMCell(...)] * num_layers), mude para: MultiRNNCell([BasicLSTMCell(...) for _ in range(num_layers)]). Se antes você estivesse usando a mesma instância de célula como célula direta e reversa de uma RNN bidirecional, basta criar duas instâncias (uma para encaminhamento e outra para reversão). Em maio de 2017, iniciaremos a transição do comportamento desta célula para usar os pesos armazenados existentes, se houver, quando ela for chamada com scope=None (o que pode levar à degradação silenciosa do modelo, portanto, esse erro permanecerá até então.)

com o fragmento de código:

  import tensorflow as tf
  from tensorflow.contrib import rnn

  hidden_size = 100
  batch_size  = 100
  num_steps   = 100
  num_layers  = 100
  is_training = True
  keep_prob   = 0.4

  input_data = tf.placeholder(tf.float32, [batch_size, num_steps])
  lstm_cell = rnn.BasicLSTMCell(hidden_size, forget_bias=0.0, state_is_tuple=True)

  if is_training and keep_prob < 1:
      lstm_cell = rnn.DropoutWrapper(lstm_cell)
  cell = rnn.MultiRNNCell([lstm_cell for _ in range(num_layers)], state_is_tuple=True)

  _initial_state = cell.zero_state(batch_size, tf.float32)

  iw = tf.get_variable("input_w", [1, hidden_size])
  ib = tf.get_variable("input_b", [hidden_size])
  inputs = [tf.nn.xw_plus_b(i_, iw, ib) for i_ in tf.split(input_data, num_steps, 1)]

  if is_training and keep_prob < 1:
      inputs = [tf.nn.dropout(input_, keep_prob) for input_ in inputs]

  outputs, states = rnn.static_rnn(cell, inputs, initial_state=_initial_state)

Eu pesquisei sem sorte, alguém pode me mostrar uma saída?

awaiting tensorflower
Fonte
picture doncat99

Comentários muito úteis

Eu encontrei o mesmo problema. Se todos vocês estão usando a versão compilada no branch master, acredito que estamos com o mesmo problema causado pelo commit recente . Como a mensagem do commit diz:

Faça com que todos os RNNCells em tf.contrib.rnn ajam como tf.layers Layers, mas com semântica mais rígida para não
C:

  1. Após o primeiro uso de __call__, o escopo usado é armazenado na célula. O RNNCell tenta criar pesos nesse escopo, mas se alguns já estiverem configurados, um erro será gerado, a menos que o RNNCell tenha sido construído com o argumento reutilização=True.

  2. Um uso subsequente de __call__ da mesma instância de célula deve estar no mesmo escopo.
    Se não for, um erro é gerado.

No meu caso, que está executando o tutorial ptb , a solução é apenas adicionar um parâmetro chamado reuse assim na linha 112:

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

Então funciona.

picture tongda em 8 mar. 2017
👍28 ❤7 🎉7 😄5

Todos 102 comentários

Estou recebendo o mesmo erro ao tentar executar o exemplo de tradução (mesmo ao fazer o pequeno autoteste) que pode ser encontrado aqui: https://github.com/tensorflow/models/tree/master/tutorials/rnn/translate

ghost picture ghost em 8 mar. 2017
👍22

Eu encontrei o mesmo problema. Se todos vocês estão usando a versão compilada no branch master, acredito que estamos com o mesmo problema causado pelo commit recente . Como a mensagem do commit diz:

Faça com que todos os RNNCells em tf.contrib.rnn ajam como tf.layers Layers, mas com semântica mais rígida para não
C:

  1. Após o primeiro uso de __call__, o escopo usado é armazenado na célula. O RNNCell tenta criar pesos nesse escopo, mas se alguns já estiverem configurados, um erro será gerado, a menos que o RNNCell tenha sido construído com o argumento reutilização=True.

  2. Um uso subsequente de __call__ da mesma instância de célula deve estar no mesmo escopo.
    Se não for, um erro é gerado.

No meu caso, que está executando o tutorial ptb , a solução é apenas adicionar um parâmetro chamado reuse assim na linha 112:

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

Então funciona.

tongda picture tongda em 8 mar. 2017
👍28 ❤7 🎉7 😄5

@ebrevdo Você poderia dar uma olhada nisso?

prb12 picture prb12 em 8 mar. 2017

O problema se replica para mim ao usar o Windows/GPU build 105 no Shakespeare RNN Repo .

Ao executar o código com a versão Win 1.0.0/GPU, não há problema.

tomwanzek picture tomwanzek em 9 mar. 2017

Esse repositório parece ser direcionado ao tf 1.0, não a versões intermediárias.

Em 8 de março de 2017, 15h56, "Tom Wanzek" [email protected] escreveu:

O problema se replica para mim ao usar o Windows/GPU build 105 no Shakespeare
RNN Repo https://github.com/martin-gorner/tensorflow-rnn-shakespeare .

Ao executar o código com a versão Win 1.0.0/GPU, não há problema.

—
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285209555 ,
ou silenciar o thread
https://github.com/notifications/unsubscribe-auth/ABtim5ansaL1KN51T4nCaqLnqw2QHN4Wks5rj0BBgaJpZM4MWl4f
.

ebrevdo picture ebrevdo em 9 mar. 2017

@tongda , estou usando a versão de lançamento do Tensorflow 1.0, trabalhando no MacOS no modo cpu. Vou mudar para o branch master para ver se funciona adicionando o parâmetro "reuse", obrigado.

doncat99 picture doncat99 em 9 mar. 2017

doncat99: se você fizer isso, certifique-se de que seu código consulte a versão do tensorflow
e gera um sinalizador se a versão for inferior à versão do branch master.
você pode precisar verificar contra:

das versões de importação tensorflow.core
versões.GIT_VERSION

Em quarta-feira, 8 de março de 2017 às 18h58, doncat99 [email protected] escreveu:

@tongda https://github.com/tongda , estou usando a versão de lançamento do
Tensorflow 1.0, trabalhando no MacOS no modo cpu. vou mudar para o mestre
branch para ver se funciona adicionando o parâmetro "reuse", obrigado.

—
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285240438 ,
ou silenciar o thread
https://github.com/notifications/unsubscribe-auth/ABtim66cU9e16lgD-2D0QLGcQCiHbV0zks5rj2rbgaJpZM4MWl4f
.

ebrevdo picture ebrevdo em 9 mar. 2017

@ebrevdo Então, quais seriam as alterações sugeridas no Shakepeare RNN para permitir que ele funcione com a versão estável intermediária?

Aqui está a seção arquitetônica chave do código, que agora falha com o build#105:

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

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

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

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

Eu não pareço encontrar nenhuma documentação sobre um sinalizador reuse ?

Desde já, obrigado.

tomwanzek picture tomwanzek em 10 mar. 2017

Usar:

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

O que cria um objeto grucell separado para cada camada.

Em 10 de março de 2017 07:44, "Tom Wanzek" [email protected] escreveu:

@ebrevdo https://github.com/ebrevdo Então qual seria a sugestão
mudanças no Shakepeare RNN para permitir que ele funcione com o intermediário
versão estável?

Aqui está a seção de arquitetura chave do código, que agora falha com
construção nº 105:

o modelo (veja FAQ em README.md)

lr = tf.placeholder(tf.float32, name='lr') # taxa de aprendizado
pkeep = tf.placeholder(tf.float32, name='pkeep') # parâmetro dropout
batchsize = tf.placeholder(tf.int32, name='batchsize')

entradas

X = tf.placeholder(tf.uint8, [None, None], name='X') # [ BATCHSIZE, SEQLEN ]
Xo = tf.one_hot(X, ALPHASIZE, 1.0, 0.0) # [ BATCHSIZE, SEQLEN, ALPHASIZE ]# saídas esperadas = mesma sequência deslocada em 1 já que estamos tentando prever o próximo caractere
Y_ = tf.placeholder(tf.uint8, [None, None], name='Y_') # [ BATCHSIZE, SEQLEN ]
Yo_ = tf.one_hot(Y_, ALPHASIZE, 1.0, 0.0) # [ BATCHSIZE, SEQLEN, ALPHASIZE ]# estado de entrada
Hin = tf.placeholder(tf.float32, [Nenhum, INTERNALSIZE*NLAYERS], name='Hin') # [ BATCHSIZE, INTERNALSIZE * NLAYERS]

usando NLAYERS=3 camadas de células GRU, desenrolado SEQLEN=30 vezes# dynamic_rnn infere SEQLEN do tamanho das entradas 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 ] # este é o último estado na sequência

Parece que não encontrei nenhuma documentação sobre um sinalizador de reutilização?

Desde já, obrigado.

—
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285702372 ,
ou silenciar o thread
https://github.com/notifications/unsubscribe-auth/ABtim6MOOCbx3RJEJe8PQBDXGVIXTGPmks5rkW_jgaJpZM4MWl4f
.

ebrevdo picture ebrevdo em 15 mar. 2017

Não entendo por que estou recebendo este erro com o modelo de tutorial seq2seq :

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

Fonte

onde a célula é criada com

def single_cell():
    return tf.contrib.rnn.GRUCell(size)
BSVogler picture BSVogler em 15 mar. 2017
👍20 😄1

@ebrevdo Obrigado por retornar a este problema. Infelizmente, a alteração sugerida deixa as coisas como estão, com o erro mencionado. Dado o comentário acima sobre o tutorial seq2seq , suspeito que estamos todos no mesmo barco?

tomwanzek picture tomwanzek em 15 mar. 2017

Tem certeza que é exatamente o mesmo erro? Por favor, copie e cole aqui.

ebrevdo picture ebrevdo em 16 mar. 2017

Foi mal, acabei de passar pelo processo de alteração para o código relevante novamente (do zero) e executei novamente conforme proposto. O erro foi realmente removido e o Velho Bardo está alucinando bem agora 👍

Então, obrigado, não tenho certeza onde errei ontem, mas estava claramente em mim.

tomwanzek picture tomwanzek em 16 mar. 2017

Eu encontrei o mesmo problema ao usar a versão de lançamento do Tensorflow 1.0 e trabalhar no MacOS no modo cpu. Mesmo se adicionar o parâmetro "reuse"

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

muticell = tf.contrib.rnn.MultiRNNCell([cell for _ in range(num_layers)], state_is_tuple=True)
bingfengyiren picture bingfengyiren em 17 mar. 2017

seu multicell parece errado... você deveria estar usando "cell() for _ in
alcance(...)"

Em qui, 16 de março de 2017 às 20h29, cuiming [email protected] escreveu:

Encontrei o mesmo problema ao usar a versão de lançamento do Tensorflow 1.0
e trabalhando no MacOS no modo cpu. Mesmo se adicionar o parâmetro "reuse"

def célula():
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)

—
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-287257629 ,
ou silenciar o thread
https://github.com/notifications/unsubscribe-auth/ABtim3A6JQr8ptRKrdiDW_kgNRIFkHGlks5rmf4WgaJpZM4MWl4f
.

ebrevdo picture ebrevdo em 17 mar. 2017

Eu estava tentando executar o exemplo de tradução: python2.7 translate.py --data_dir data/ --train_dir train/ --size=256 --num_layers=2 --steps_per_checkpoint=50

Parece que a maneira de usar o MultiRNNCell está correta:
célula = tf.contrib.rnn.MultiRNNCell([single_cell() for _ in range(num_layers)])

Mas recebi o mesmo erro:
ValueError: Tentativa de reutilizar RNNCellcom um escopo de variável diferente do seu primeiro uso. O primeiro uso da célula foi com o escopo 'embedding_attention_seq2seq/embedding_attention_decoder/attention_decoder/multi_rnn_cell/cell_0/gru_cell', esta tentativa é com o escopo 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_0/gru_cell'. Crie uma nova instância da célula se desejar que ela use um conjunto diferente de pesos. Se antes você estava usando: MultiRNNCell([GRUCell(...)] * num_layers), mude para: MultiRNNCell([GRUCell(...) for _ in range(num_layers)]). Se antes você estivesse usando a mesma instância de célula como célula direta e reversa de uma RNN bidirecional, basta criar duas instâncias (uma para encaminhamento e outra para reversão). Em maio de 2017, iniciaremos a transição do comportamento desta célula para usar os pesos armazenados existentes, se houver, quando ela for chamada com scope=None (o que pode levar à degradação silenciosa do modelo, portanto, esse erro permanecerá até então.)

bowu picture bowu em 26 mar. 2017
👍10

@bowu - você teve alguma sorte com isso? se você ainda não experimentou, reinstale o tensorflow da fonte mais recente. houve algumas mudanças em alguns dos arquivos core_rnn, entre alguns outros. funciona para mim agora.

robmsylvester picture robmsylvester em 29 mar. 2017

@robmsylvester Eu reinstalo o tensorflow da fonte mais recente, ainda o mesmo erro. Eu estava no branch master e o último commit é commit 2a4811054a9e6b83e1f5a2705a92aab50e151b13 . Qual é o commit mais recente quando você cria seu repositório?

oxwsds picture oxwsds em 30 mar. 2017

Oi, estou usando o Tensorflow r1.0 usando a GPU construída usando a fonte. Estou tentando seguir o tutorial de tradução Seq2Seq não modificado, mas estou recebendo o mesmo erro. ou seja

ValueError: Tentativa de reutilizar RNNCellcom um escopo de variável diferente do seu primeiro uso. O primeiro uso da célula foi com escopo 'embedding_attention_seq2seq/embedding_attention_decoder/attention_decoder/multi_rnn_cell/cell_0/gru_cell', esta tentativa é com escopo 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_0/gru_cell'.....

A parte relevante do código no meu seq2seq_model.py é:

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

O que posso fazer para resolver o problema?

adicionar "reuse=tf.get_variable_scope().reuse" à chamada onde o GRUCell é criado não ajuda.

Muito obrigado!

prashantserai picture prashantserai em 3 abr. 2017
👍5

@prashantserai - veja o que acontece se você remover a linha MultiRNNCell de cima, efetivamente tornando sua rede apenas uma camada. Funciona então? Pode ser um bug em algum lugar no MultiRNNCell. Eu li sobre isso em algum lugar recentemente, provavelmente no estouro da pilha.

Se você mesmo implementar o lstm/gru empilhado, não receberá esse erro e poderá implementar a mesma funcionalidade (na verdade, mais, porque você é livre para fazer o que quiser com arquiteturas bidirecionais, conexões estranhas residuais e pular, etc. .)

robmsylvester picture robmsylvester em 4 abr. 2017

@robmsylvester O mesmo erro persistiu mesmo quando tentei com num_layers=1, o que deve efetivamente pular essa linha. Alguma outra ideia? Obrigado pela contribuição.

prashantserai picture prashantserai em 4 abr. 2017
👍3 👎1

Hmmm. Uma coisa que se destaca para mim está no arquivo seq2seq legado referenciado:

encoder_cell = copy.deepcopy(cell)

Esta linha parece ser usada porque a mesma arquitetura é usada no lado do codificador e do decodificador. Eles fazem uma cópia da célula e, em seguida, passam o argumento da célula para a função de incorporação do decodificador de atenção e, em seguida, para o próprio decodificador de atenção.

O que acontece se você criar explicitamente a célula codificadora E a célula decodificadora em seu arquivo de modelo seq2seq e passar ambas para o arquivo de biblioteca legado, fazendo os pequenos ajustes nas funções e seus argumentos?

robmsylvester picture robmsylvester em 4 abr. 2017
👍1

@robmsylvester não deveria fazer alterações nos escopos das células funcionar? Está funcionando para os outros dois exemplos também. Na minha opinião, isso seria uma solução muito feia; deve existir uma solução mais limpa; talvez estejamos perdendo alguma coisa? (Eu também recebi o mesmo erro no tutorial seq2seq, tentei todas as soluções acima).

iamgroot42 picture iamgroot42 em 4 abr. 2017

@iamgroot42 - Sim, essa 'solução' é reconhecidamente muito feia, mas mais ainda tentando caçar onde pode estar um problema. Vou brincar com ele em algumas horas e ver se consigo rastrear algo.

robmsylvester picture robmsylvester em 4 abr. 2017

Na verdade, o copy.deepcopy existe porque são funções legadas e
não temos recursos para mantê-los/atualizá-los. Se você gostaria de
introduzir uma alteração compatível com versões anteriores que permita ao usuário fornecer um
segunda célula para a etapa de decodificação e, se for Nenhum, para retornar ao
deepcopy, então eu ficaria feliz em revisar o PR. Tenha em mente que seria
tem que ser uma mudança compatível com versões anteriores.

Em terça-feira, 4 de abril de 2017 às 11h38, Rob Sylvester [email protected]
escreveu:

@iamgroot42 https://github.com/iamgroot42 - Sim, essa 'solução' é
reconhecidamente muito feio, mas mais ainda tentando caçar onde um problema
pode ser. Vou jogar com ele em algumas horas e ver se consigo rastrear algo
baixa.

—
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-291593289 ,
ou silenciar o thread
https://github.com/notifications/unsubscribe-auth/ABtim1QHTDhOC_zT6cKtmUFPOit5Yjn7ks5rso5CgaJpZM4MWl4f
.

ebrevdo picture ebrevdo em 6 abr. 2017

@ebrevdo - Vou pensar nisso. Eu tenho um tradutor que funciona bem parecido com este, mas cria células através de uma classe separada que permite inserir camadas bidirecionais onde você quiser, resíduos onde quiser, mesclar entradas com concat vs. sum e algumas outras coisas. Acho que poderia migrar minha classe para este tutorial com bastante facilidade usando RNNs estáticos. Eu aviso você.

robmsylvester picture robmsylvester em 6 abr. 2017

@ebrevdo estou executando o Tensorflow r1.0 (tensorflow-1.0.1-cp36-cp36m-linux_x86_64) no Red Hat e tenho a versão mais recente do tutorial de tradução do Github.

prashantserai picture prashantserai em 6 abr. 2017

É uma pena que o tutorial de tradução não funcione com o TF 1.0. Devemos consertar isso. @lukaszkaiser você pode dar uma olhada? Estamos trabalhando em um novo tutorial, mas ainda faltam algumas semanas e exigirá uma versão noturna do TensorFlow (ou TF 1.1 ou 1.2) para funcionar.

ebrevdo picture ebrevdo em 6 abr. 2017

(lukasz; é difícil para mim identificar pelos vários comentários qual parte do tutorial está com defeito no TF 1.0. Alguma chance de você identificar a linha e eu posso ajudar a fazê-la funcionar?)

ebrevdo picture ebrevdo em 6 abr. 2017

@ebrevdo É este tutorial. O erro está neste cluster de linhas. As células passadas aqui são usadas para a fase de retrocesso e avanço do modelo seq2seq herdado, que gera um erro porque as mesmas células estão sendo usadas com escopos diferentes.

iamgroot42 picture iamgroot42 em 6 abr. 2017

@iamgroot42 você quer fazer um PR com as mudanças necessárias? Isso seria ótimo, atualmente não tenho ciclos para fazer isso sozinho. Obrigado!

lukaszkaiser picture lukaszkaiser em 6 abr. 2017

Percebi que o TF 1.0 funciona bem com a versão mais recente do tutorial de tradução se compilado a partir da fonte em branch remotes/origin/r1.0

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

em seguida, construa e instale o TensorFlow, funciona bem.

Em branch remotes/origin/r1.1 tem o erro "diferente escopo de variável".
Modifiquei o código como sugerido pelo @robmsylvester

O que acontece se você criar explicitamente a célula codificadora E a célula decodificadora em seu arquivo de modelo seq2seq e passar ambas para o arquivo de biblioteca legado, fazendo os pequenos ajustes nas funções e seus argumentos?

e funciona para mim agora.

oxwsds picture oxwsds em 6 abr. 2017
👍1

@oxwsds o Tensorflow que estou usando é 1.0.1, então talvez esteja tendo um erro ..

Eu tentei o que @robmsylvester sugeriu na verdade .. e o treinamento começou (2 dias 13 horas feito agora) .. ele falha durante a decodificação, embora com o erro:

  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)

Você tentou decodificar?

prashantserai picture prashantserai em 8 abr. 2017

@prashantserai Não sei exatamente, mas o que você conheceu parece ser outro problema.

oxwsds picture oxwsds em 10 abr. 2017

@prashantserai Se falhar apenas quando você decodificar, talvez tenha algo a ver com o uso de um tamanho de lote de um? O modelo ainda treina se você diminuir o tamanho do lote para um durante o treinamento?

robmsylvester picture robmsylvester em 10 abr. 2017

@bowu Mesmo erro aqui. Mac OX Sierra, TensorFlow 1.1.0-rc1, Python 2.7.10 e Python 3.6.1.

soloice picture soloice em 10 abr. 2017

@robmsylvester , ele treinou com sucesso com um tamanho de lote de um também, mas falhou durante a decodificação da mesma maneira ou de maneira semelhante. seq2seq_f (que foi uma das funções modificadas) (o comentário #prashant do meu código para significar uma linha modificada faz parte do rastreamento)

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 sua opinião muda com base no rastreamento completo acima?

prashantserai picture prashantserai em 10 abr. 2017

@prashantserai tentei decodificar e funciona bem. Eu simplesmente adiciono um argumento encoder_cell à função tf.contrib.legacy_seq2seq.embedding_attention_seq2seq e em translate/seq2seq_model.py crio a célula e a passo para a função, que foi chamada na função seq2seq_f . Como você alterou seu código?

oxwsds picture oxwsds em 11 abr. 2017
👍1

@oxwsds @robmsylvester @ebrevdo
Eu finalmente tenho algo que está funcionando agora (quer dizer, os resultados para minha rede de 256 unidades de camada única são meio assustadores, mas isso é provavelmente apenas porque a rede é ultra leve e eu não ajustei os parâmetros).
Muito obrigado a todos...!!!!!

_Aqui estão meus pensamentos no final disso:_

@oxwsds comenta que o tutorial (em sua forma atual) funciona sem qualquer necessidade de modificação quando o Tensorflow é compilado a partir do branch remotes/origin/r1.0 was TRUE . Embora, a parte triste foi que a versão do Tensorflow que eu tinha para a qual eram necessárias modificações no código do Tensorflow, e a versão em remotes/origin/r1.0 foram rotuladas de forma idêntica.

A correção do @robmsylvester no comentário (copiado abaixo) FUNCIONOU para minha versão do Tensorflow onde o Tutorial não funcionou imediatamente (e deve funcionar para o TF 1.1 também, eu acho). É um pouco confuso de implementar, mas eu poderia fazê-lo, o que significa algo :-P
O erro nos meus dois últimos comentários antes disso foi devido ao meu erro. Como um manequim, eu estava especificando os parâmetros das camadas e unidades ocultas apenas durante o treinamento, deixando o código para usar os padrões durante a decodificação. (esta parte do tutorial pode ser um pouco mais falsa: https://www.tensorflow.org/tutorials/seq2seq#lets_run_it )

Hmmm. Uma coisa que se destaca para mim está no arquivo seq2seq legado referenciado:

encoder_cell = copy.deepcopy(cell)

Esta linha parece ser usada porque a mesma arquitetura é usada no lado do codificador e do decodificador. Eles fazem uma cópia da célula e, em seguida, passam o argumento da célula para a função de incorporação do decodificador de atenção e, em seguida, para o próprio decodificador de atenção.

O que acontece se você criar explicitamente a célula codificadora E a célula decodificadora em seu arquivo de modelo seq2seq e passar ambas para o arquivo de biblioteca legado, fazendo os pequenos ajustes nas funções e seus argumentos?

prashantserai picture prashantserai em 11 abr. 2017
👍1

Obrigado pelo feedback! Parece que há algo diferente entre o TF
em pypi e nessa tag? Gunhan, isso é possível?

Em segunda-feira, 10 de abril de 2017 às 21h05, prashantserai [email protected]
escreveu:

@oxwsds https://github.com/oxwsds @robmsylvester
https://github.com/robmsylvester @ebrevdo https://github.com/ebrevdo
Eu finalmente tenho algo que está funcionando agora (quer dizer, resultados para meu single
rede de unidades de camada 256 são meio assustadoras, mas isso provavelmente é apenas
porque a rede é ultra leve e eu não ajustei os parâmetros de forma alguma)

Aqui está minha linha de fundo:

@oxwsds https://github.com/oxwsds comenta que o tutorial (em seuatual) funciona sem qualquer necessidade de modificação quando o Tensorflow écompilado do branch remotes/origin/r1.0 era TRUE . A parte triste
apesar de ser essa a versão do Tensorflow que eu tinha para quais modificações
dentro do código do Tensorflow eram necessários, e a versão em remotes/origin/r1.0
foram ambos identicamente rotulados.

@robmsylvester https://github.com/robmsylvester's fix no comentário
(copiado abaixo) FUNCIONOU para minha versão do Tensorflow onde o Tutorial
não funcionou fora da caixa (e deve funcionar para o TF 1.1 também, eu acho). Isto é
um pouco confuso para implementar, mas eu poderia fazê-lo, o que está dizendo algo
:-P
O erro nos meus dois últimos comentários antes disso foi devido ao meu erro. Como
um manequim, eu estava especificando apenas os parâmetros de camadas e unidades ocultas
durante o treinamento, eu estava deixando o código para usar os padrões durante a decodificação. (istoparte do tutorial pode ser um pouco mais falsa:https://www.tensorflow.org/tutorials/seq2seq#lets_run_ithttps://www.tensorflow.org/tutorials/seq2seq#lets_run_it )

Hmmm. Uma coisa que se destaca para mim está no legado referenciado seq2seq
Arquivo:

encoder_cell = copy.deepcopy(cell)

Esta linha parece ser usada porque a mesma arquitetura é usada em ambos
o lado do codificador e do decodificador. Eles fazem uma cópia da célula, depois passam o
argumento de célula junto com a função de incorporação do decodificador de atenção e, em seguida, para
o próprio decodificador de atenção.

O que acontece se você criar explicitamente a célula do codificador E o decodificador
cell em seu arquivo de modelo seq2seq e passe ambos para a biblioteca legada
arquivo, fazendo os pequenos ajustes nas funções e seus argumentos?

—
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-293143828 ,
ou silenciar o thread
https://github.com/notifications/unsubscribe-auth/ABtimxvcfFnbWbpj7aUs3BUjwGEFj6p5ks5ruvvygaJpZM4MWl4f
.

ebrevdo picture ebrevdo em 11 abr. 2017

Para obter informações, tive esse problema ao tentar empilhar células LSTM:
Meu 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)

Então, com o código a seguir, a criação do modelo foi ok, mas não consegui compartilhar a variável com outro modelo. (por exemplo, se você criar um train_model e um valid_model supostamente para compartilhar tensores, ele falhará)

    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)

Então, finalmente, usei lstm_creator para ser a função como lstm_cell em tensorflow/models/tutorials/rnn/ptb/ptb_word_lm.py#L112 . agora tenho:

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)

Já está funcionando totalmente

pltrdy picture pltrdy em 13 abr. 2017
👍3

tentando fazer isso funcionar, o que resulta no mesmo erro:

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

A solução do @pltrdy não fez isso para mim estranhamente. Estou entendendo

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 picture aep em 16 abr. 2017

@aep você usou a função de https://github.com/tensorflow/models/blob/master/tutorials/rnn/ptb/ptb_word_lm.py#L112 que menciono no final do meu post (agora editado para ficar mais claro )

pltrdy picture pltrdy em 18 abr. 2017 
cells=[]
for _ in range(15):
    cell = create_lstm_cell(config)
    cells.append(cell)
lsmt_layers = rnn.MultiRNNCell(cells)

resolveu meu problema

Tshzzz picture Tshzzz em 28 abr. 2017

Gerenciado para corrigir esse problema instalando a versão mais antiga do Tensorflow:
pip install -Iv tensorflow==1.0

Eu estava recebendo o erro ao executar o tutorial seq2seq

dsoiM picture dsoiM em 28 abr. 2017
👍10 ❤1 🎉1

Em relação ao que @ebrevdo disse, acho que a solução não é corrigir o código seq2seq legado, mas atualizar o tutorial para usar o pacote contrib.seq2seq , que é mantido ativamente. É bastante desmoralizante quando o primeiro programa tensorflow que você executa cospe um monte de erros. Se eu tiver algum tempo esta semana, enviarei um PR.

kyteague picture kyteague em 1 mai. 2017
👍2

Estamos trabalhando em um novo tutorial seq2seq. Esperávamos lançar até o final de
no mês passado, mas estão ficando atrasados. Ele usará a nova API.

Em 1º de maio de 2017 08:07, "Kyle Teague" [email protected] escreveu:

Em relação ao que @ebrevdo https://github.com/ebrevdo disse, eu acho
a solução não é corrigir o código seq2seq legado, mas atualizar o
tutorial para usar o pacote contrib.seq2seq, que é ativamente
mantido. É bastante desmoralizante quando o primeiro programa tensorflow você
nunca executar cospe um monte de erros. Se eu tiver algum tempo esta semana, eu vou
apresentar um PR.

—
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-298350307 ,
ou silenciar o thread
https://github.com/notifications/unsubscribe-auth/ABtim587xZx9Gi4-yXmwccSum8_Trc1oks5r1fUogaJpZM4MWl4f
.

ebrevdo picture ebrevdo em 1 mai. 2017

@ebrevdo encontro o mesmo erro ao executar o modelo sequence_to_sequence no site tensorflow1.1. E eu tentei usar o parâmetro 'reuse', mas falhei. Você poderia me dizer quando o novo tutorial seq2seq será lançado?

njuzrs picture njuzrs em 5 mai. 2017

Parece ao mesmo tempo que o tf 1.2, já que vamos contar com alguns novos
características desse lançamento.

Em 4 de maio de 2017, 21h16, "njuzrs" [email protected] escreveu:

@ebrevdo https://github.com/ebrevdo Eu encontro o mesmo erro ao executar
o modelo sequence_to_sequence no site tensorflow1.1. E eu tentei
para usar o parâmetro 'reuse', mas falhou. Você poderia me dizer quando o novo seq2seq
tutorial será lançado?

—
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-299366774 ,
ou silenciar o thread
https://github.com/notifications/unsubscribe-auth/ABtim8_kFTM7-SsXQAA-Ar0dfhHMGT0Zks5r2qKngaJpZM4MWl4f
.

ebrevdo picture ebrevdo em 5 mai. 2017

@ebrevdo Também estou enfrentando o mesmo problema e não consigo progredir com o seq2seq. Será muito útil se você puder nos informar qual é uma data provável para um novo tutorial.
Muito obrigado por sua ajuda.

PratsBhatt picture PratsBhatt em 8 mai. 2017
👍7

Instalar usando pip install tensorflow==1.0 (Tensorflow 1.0) está funcionando para mim (tutorial de tradução).

tanmayb123 picture tanmayb123 em 9 mai. 2017

Eu tenho a versão 1.1.0-rc2.

PratsBhatt picture PratsBhatt em 9 mai. 2017

TF1.2 vai resolver esse problema? Por favor me ajude como continuar treinando o modelo. O TF 1.0 funciona, mas não possui api devicewrapper para várias GPUs.

MingCong18 picture MingCong18 em 15 mai. 2017

Tendo o mesmo problema com o fluxo tensor 1.1. Ainda trabalhando em uma solução

thomasqjohns picture thomasqjohns em 19 mai. 2017

Tentei várias coisas, no final consegui usar o tensorflow 1.1 mas tive que fazer essas mudanças: (baseado no Tshzzz acima)

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

E adicione isso:
células=[]
para _ no intervalo (NLAYERS):
cell = rnn.DropoutWrapper(tf.contrib.rnn.GRUCell(INTERNALSIZE), input_keep_prob=pkeep)
células.append(célula)
multicell = rnn.MultiRNNCell(cells, state_is_tuple=False)

jtubert picture jtubert em 20 mai. 2017
👍3

@ebrevdo Parabéns, o TF 1.2 acabou de ser lançado - o novo tutorial também foi lançado em algum lugar ou será lançado em breve?

Obrigado

prashantserai picture prashantserai em 20 mai. 2017

Planejamos ter um anúncio quando for lançado. Trabalhando nisso.

Em 19 de maio de 2017, 19h02, "prashantserai" [email protected] escreveu:

@ebrevdo https://github.com/ebrevdo Parabéns, TF 1.2 acabou de chegar
lançado - o novo tutorial também foi lançado em algum lugar ou está sendo
lançado em breve?

Obrigado

—
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-302844002 ,
ou silenciar o thread
https://github.com/notifications/unsubscribe-auth/ABtim0RWDzNCXk-bIjKSyHLvgFxUvq2lks5r7km7gaJpZM4MWl4f
.

ebrevdo picture ebrevdo em 20 mai. 2017
👍2

Para qualquer um usando tensorflow-gpu==1.1.0 e recebendo este erro, mudar para 1.0.0 via pip install tensorflow-gpu==1.0.0 não vai resolver o problema, pelo menos não funcionou para mim.

Eu encontrei esse problema no mac e no ubuntu e a compilação da fonte funcionou nas duas vezes. Assim:
instalação do pip https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.0.0-cp34-cp34m-linux_x86_64.whl

ajaanbaahu picture ajaanbaahu em 24 mai. 2017

@ajaanbaahu Ainda esperando pelo novo tutorial do tf1.2 seq2seq.

MingCong18 picture MingCong18 em 25 mai. 2017
👍3

Funcionou para mim usando pip install tensorflow==1.0 .

saching270 picture saching270 em 26 mai. 2017

Para tf r1.2, ocorreu um erro de deepcopy. Conforme listado na sequência para o erro de modelo de sequência nº 1050

Vimos picture Vimos em 26 mai. 2017

Como o novato, eu levanto um pouco da minha opinião.
O código a seguir fará com que esse erro semelhante ocorra:
(parte do meu 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)

O dump de erro como o seguinte:

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

Mas depois que eu fizer a revisão, pode 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)
SunnerLi picture SunnerLi em 29 mai. 2017

Nenhuma dessas soluções funcionou para mim com o Tensorflow 1.1

Estou usando o modelo seq2seq com células MultiRNNCell .

Eu tive que reverter para 1.0.1: pip3 install tensorflow==1.0

philipperemy picture philipperemy em 2 jun. 2017
👍6

Alguém tem esses problemas ao trabalhar com legacy_seq2seq.rnn_decoder()?

rileyedmunds picture rileyedmunds em 6 jun. 2017

@oxwsds Como você disse, altero a célula de argumentos de entrada de tf.contrib.legacy_seq2seq.embedding_attention_seq2seq para duas células diferentes {encoder_cells, decoder_cells}. Finalmente, recebo o modelo seq2seq trabalhado. Após 73200 setps, recebo perplexidade 5,54.
Então eu executo a parte de decodificação,

Quem é o presidente dos Estados Unidos?
Qui est le presidente des États-Unis ?

Problema resolvido. Obrigado.

supermeatboy82 picture supermeatboy82 em 7 jun. 2017

@doncat99
Parece que copy.deepcopy(cell) em seq2seq.py não faz efeito.
Então eu mudo a parte relacionada em seq2seq_model.py para

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)
ypruan picture ypruan em 15 jun. 2017
👍2

@supermeatboy82 , você poderia compartilhar seu código?

martinambition picture martinambition em 19 jun. 2017

Atualizar para o Tensorflow 1.2.0 e gerar as células em um loop em vez da multiplicação da lista corrigiu isso para mim.

cpury picture cpury em 21 jun. 2017

Obteve o erro com o TF1.2 ao executar o translate.py, detalhes:
nome: GeForce GTX 1080 Ti
major: 6 minor: 1 memoryClockRate (GHz) 1,582
pciBusID 0000:02:00.0
Memória total: 10,91 GiB
Memória livre: 10,76 GiB
22/06/2017 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] Criando dispositivo TensorFlow (/gpu:0) -> (dispositivo: 0, nome: GeForce GTX 1080 Ti, pci código do ônibus: 0000:02:00.0)
Criando 3 camadas de 1024 unidades.
Traceback (última chamada mais recente):
Arquivo "translate.py", linha 322, em
tf.app.run()
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/python/platform/app.py", linha 48, em execução
_sys.exit(main(_sys.argv[:1] + flags_passthrough))
Arquivo "translate.py", linha 319, em main
Comboio()
Arquivo "translate.py", linha 178, em train
model = create_model(sess, False)
Arquivo "translate.py", linha 136, em create_model
dtipo=dtipo)
Arquivo "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", linha 179, em __init__
softmax_loss_function=softmax_loss_function)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", linha 1206, em model_with_buckets
decoder_inputs[:bucket[1]])
Arquivo "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", linha 178, em
lambda x, y: seq2seq_f(x, y, False),
Arquivo "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", linha 142, em seq2seq_f
dtipo=dtipo)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", linha 848, em embedding_attention_seq2seq
encoder_cell = copy.deepcopy(cell)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 174, em deepcopy
y = copiadora(memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/python/layers/base.py", linha 476, em __deepcopy__
setattr(resultado, k, copy.deepcopy(v, memo))
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 163, em deepcopy
y = copiadora(x, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 230, em _deepcopy_list
y.append(deepcopy(a, memo))
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 190, em deepcopy
y = _reconstruir(x, rv, 1, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 334, em _reconstruct
estado = deepcopy(estado, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 163, em deepcopy
y = copiadora(x, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 257, em _deepcopy_dict
y[deepcopy(chave, memorando)] = deepcopy(valor, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 190, em deepcopy
y = _reconstruir(x, rv, 1, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 334, em _reconstruct
estado = deepcopy(estado, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 163, em deepcopy
y = copiadora(x, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 257, em _deepcopy_dict
y[deepcopy(chave, memorando)] = deepcopy(valor, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 190, em deepcopy
y = _reconstruir(x, rv, 1, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 334, em _reconstruct
estado = deepcopy(estado, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 163, em deepcopy
y = copiadora(x, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 257, em _deepcopy_dict
y[deepcopy(chave, memorando)] = deepcopy(valor, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 190, em deepcopy
y = _reconstruir(x, rv, 1, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 334, em _reconstruct
estado = deepcopy(estado, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 163, em deepcopy
y = copiadora(x, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 257, em _deepcopy_dict
y[deepcopy(chave, memorando)] = deepcopy(valor, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 163, em deepcopy
y = copiadora(x, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 257, em _deepcopy_dict
y[deepcopy(chave, memorando)] = deepcopy(valor, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 163, em deepcopy
y = copiadora(x, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 230, em _deepcopy_list
y.append(deepcopy(a, memo))
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 190, em deepcopy
y = _reconstruir(x, rv, 1, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 334, em _reconstruct
estado = deepcopy(estado, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 163, em deepcopy
y = copiadora(x, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 257, em _deepcopy_dict
y[deepcopy(chave, memorando)] = deepcopy(valor, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 190, em deepcopy
y = _reconstruir(x, rv, 1, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 334, em _reconstruct
estado = deepcopy(estado, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 163, em deepcopy
y = copiadora(x, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 257, em _deepcopy_dict
y[deepcopy(chave, memorando)] = deepcopy(valor, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 190, em deepcopy
y = _reconstruir(x, rv, 1, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 334, em _reconstruct
estado = deepcopy(estado, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 163, em deepcopy
y = copiadora(x, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 257, em _deepcopy_dict
y[deepcopy(chave, memorando)] = deepcopy(valor, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 163, em deepcopy
y = copiadora(x, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 230, em _deepcopy_list
y.append(deepcopy(a, memo))
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 163, em deepcopy
y = copiadora(x, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 237, em _deepcopy_tuple
y.append(deepcopy(a, memo))
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 163, em deepcopy
y = copiadora(x, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 257, em _deepcopy_dict
y[deepcopy(chave, memorando)] = deepcopy(valor, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 190, em deepcopy
y = _reconstruir(x, rv, 1, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 334, em _reconstruct
estado = deepcopy(estado, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 163, em deepcopy
y = copiadora(x, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 257, em _deepcopy_dict
y[deepcopy(chave, memorando)] = deepcopy(valor, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 190, em deepcopy
y = _reconstruir(x, rv, 1, memorando)
Arquivo "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", linha 343, em _reconstruct
y.__dict__.update(estado)
AttributeError: o objeto 'NoneType' não tem atributo 'update'

syw2014 picture syw2014 em 22 jun. 2017

Também encontrei o erro causado por copy.deepcopy(cell) em embedding_attention_seq2seq() ao executar self_test() no modelo de tradução no tutorial.
Tentei alterar os códigos em seq2seq_f() em Seq2SeqModel da seguinte forma:

    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)

Então não há erro agora.
MAS, como novato, não sei se os códigos aqui funcionam como antes e parece que as alterações tornam o modelo mais lento.

Miopas picture Miopas em 23 jun. 2017
😄3 👍1

Eu gostaria de atualizar todos que eu fiz downgrade do tensorflow para 1.0.0 (tensorflow-GPU) e está funcionando para mim. Os modelos estão funcionando conforme o esperado. Presumo que a versão da CPU de 1.0.0 deve funcionar como esperado? Ou?.
Obrigado :)

PratsBhatt picture PratsBhatt em 23 jun. 2017

Olá pessoal, não sei se você ainda tem interesse nele, mas descobri que o problema está relacionado à operação de copiar a célula passada como params para a função embedding_attention_seq2seq . Isso ocorre porque a mesma definição de célula é usada para codificador e decodificador. Acho que o tutorial está obsoleto, pois usa um modelo seq2seq com bucket em contraste com um seq2seq dinâmico. Mas, estou colando uma função modificada que funciona. A função é atualizada no arquivo tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py .

obrigado,
Fábio

```!python
def embedding_attention_seq2seq(encoder_inputs,
decoder_inputs,
enc_cell,
dec_cell,
num_encoder_symbols,
num_decoder_symbols,
embedding_size,
num_heads=1,
output_projection=Nenhum,
feed_previous=Falso,
dtype=Nenhum,
escopo=Nenhum,
inicial_state_attention=Falso):
"""Incorporando modelo de sequência a sequência com atenção.

Este modelo primeiro incorpora encoder_inputs por uma incorporação recém-criada (de forma
[num_encoder_symbols x input_size]). Em seguida, ele executa um RNN para codificar
encoder_inputs embutido em um vetor de estado. Ele mantém as saídas deste
RNN em cada etapa para usar para atenção posterior. Em seguida, ele incorpora decoder_inputs
por outra incorporação recém-criada (de forma [num_decoder_symbols x
input_size]). Em seguida, ele executa o decodificador de atenção, inicializado com o último
estado do codificador, em decoder_inputs incorporados e atendendo às saídas do codificador.

Aviso: quando output_projection for None, o tamanho dos vetores de atenção
e as variáveis ​​serão proporcionais a num_decoder_symbols, podem ser grandes.

Args:
encoder_inputs: Uma lista de tensores 1D int32 de forma [batch_size].
decoder_inputs: Uma lista de tensores 1D int32 de forma [batch_size].
célula: tf.nn.rnn_cell.RNNCell definindo a função e o tamanho da célula.
num_encoder_symbols: inteiro; número de símbolos no lado do codificador.
num_decoder_symbols: inteiro; número de símbolos no lado do decodificador.
embedding_size: Inteiro, o comprimento do vetor de incorporação para cada símbolo.
num_heads: Número de cabeças de atenção que leem a partir de Attention_states.
output_projection: Nenhum ou um par (W, B) de pesos de projeção de saída e
preconceitos; W tem forma [output_size x num_decoder_symbols] e B tem
forma [num_decoder_symbols]; se fornecido e feed_previous=True, cada
a saída anterior alimentada será primeiro multiplicada por W e adicionada B.
feed_previous: Tensor booleano ou escalar booleano; se True, apenas o primeiro
de decoder_inputs será usado (o símbolo "GO") e todos os outros decodificadores
entradas serão obtidas de saídas anteriores (como em embedding_rnn_decoder).
Se False, decoder_inputs são usados ​​conforme fornecido (o caso do decodificador padrão).
dtype: O dtype do estado RNN inicial (padrão: tf.float32).
scope: VariableScope para o subgrafo criado; padrão para
"embedding_attention_seq2seq".
initial_state_attention: Se False (padrão), as atenções iniciais são zero.
Se True, inicialize as atenções do estado inicial e a atenção
estados.

Devoluções:
Uma tupla do formulário (saídas, estado), onde:
outputs: Uma lista do mesmo tamanho que decoder_inputs de tensores 2D com
forma [batch_size x num_decoder_symbols] contendo o gerado
saídas.
state: O estado de cada célula do decodificador no passo de tempo final.
É um tensor 2D de forma [batch_size x cell.state_size].
"""
com variable_scope.variable_scope(
scope ou "embedding_attention_seq2seq", dtype=dtype) como escopo:
dtype = escopo.dtype
# 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 picture fabiofumarola em 25 jun. 2017
👍14 ❤4

@fabiofumarola Obrigado pela função. Parece realmente útil. Também vi que o tutorial está obsoleto. Ainda estou esperando por um lançamento oficial do tutorial. Parece que você usou a nova API. Você tem algum código que possa ser consultado para começar a codificar na nova API?
Qualquer ajuda é bem vinda. Agradeço novamente :)

PratsBhatt picture PratsBhatt em 26 jun. 2017

@syw2014 Você corrigiu seu problema?

w268wang picture w268wang em 26 jun. 2017

@w268wang ainda não, ainda aguardando outras soluções, mas os comentários do @Miopas podem tentar, e estou tentando a solução do @fabiofumarola

syw2014 picture syw2014 em 27 jun. 2017

diz TypeError: embedding_attention_seq2seq() missing 1 required positional argument: 'dec_cell'
depois de usar a atualização que o @fabiofumarola postou. Podem por favor me ajudar?

sachinh35 picture sachinh35 em 2 jul. 2017

Sim, porque a atualização que propus exige que você altere o
Função embedding_attention_seq2seq. Se você for para o arquivo de origem em você
tensorflow, você pode alterar a definição do método que você é.

No domingo, 2 de julho de 2017 às 18:15, sachinh35 [email protected] trote

diz TypeError: embedding_attention_seq2seq() faltando 1 necessário
argumento posicional: 'dec_cell'

—
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312500996 ,
ou silenciar o thread
https://github.com/notifications/unsubscribe-auth/ABepUEc3W8m5CVDQGnCLu4dcJVFwwLDZks5sJ8IOgaJpZM4MWl4f
.

>

Enviado do Gmail Mobile

fabiofumarola picture fabiofumarola em 2 jul. 2017

Sim eu fiz a mesma coisa. Mudei a função no arquivo seq2seq.py na versão tensorflow. Ainda estou recebendo o mesmo erro. Existe mais um argumento para a função?

sachinh35 picture sachinh35 em 2 jul. 2017

Sim, agora em seu código você precisa especificar para rnn_cells. Um para o codificador
e outro para o decodificador.

Em Dom, 2 de julho de 2017 às 20:54, fabio fumarola [email protected] escreveu:

sim

Em domingo, 2 de julho de 2017 às 18:50, sachinh35 [email protected] escreveu:

Sim eu fiz a mesma coisa. Alterei a função no arquivo seq2seq.py em
a liberação do tensorflow. Ainda estou recebendo o mesmo erro. Existe um
mais argumento para a função?

—
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312503106 ,
ou silenciar o thread
https://github.com/notifications/unsubscribe-auth/ABepUOXTQC_mzLuhcwW0iZRVkLmmr8yIks5sJ8pugaJpZM4MWl4f
.

>

Enviado do Gmail Mobile

fabiofumarola picture fabiofumarola em 2 jul. 2017

Eu sou totalmente novo nisso. Talvez esta seja uma pergunta bastante básica, mas você poderia dizer qual argumento deve ser passado como a célula do decodificador neste código? Estou tentando desenvolver o seq2seq conforme mostrado no tutorial do tensorflow usando o próprio conjunto de dados.

`
de __future__ import absolute_import
da __future__ divisão de importação
de __future__ importar print_function

importar aleatório

importar numpy como np
from six.moves import xrange # pylint: disable=redefined-builtin
importe tensorflow como tf

importar dados_utils

class Seq2SeqModel(objeto):
def __init__(auto,
source_vocab_size,
target_vocab_size,
baldes,
Tamanho,
num_camadas,
max_gradient_norm,
tamanho do batch,
taxa de Aprendizagem,
learning_rate_decay_factor,
use_lstm=Falso,
num_samples=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, encoder_inputs, decoder_inputs, target_weights,
bucket_id, forward_only):

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

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

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

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

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

def get_batch(self, data, bucket_id):

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

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

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

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

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

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

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

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

Esta é uma boa pergunta para estouro de pilha.

Em 3 de julho de 2017 às 8h46, "sachinh35" [email protected] escreveu:

Eu sou totalmente novo nisso. Talvez esta seja uma pergunta bastante básica, mas você poderia
diga qual argumento deve ser passado como célula do decodificador neste código? eu sou
tentando desenvolver o seq2seq conforme mostrado no tutorial do tensorflow usando o próprio
conjunto de dados.
`# Copyright 2015 Os autores do TensorFlow. Todos os direitos reservados.
Licenciado sob a Licença Apache, Versão 2.0 (a "Licença"); você pode
não use este arquivo exceto em conformidade com a Licença. Você pode obter um
cópia da Licença em http://www.apache.org/licenses/LICENSE-2.0 A menos que
exigido pela lei aplicável ou acordado por escrito, software distribuído
sob a Licença é distribuído "COMO ESTÁ", SEM GARANTIAS
OU CONDIÇÕES DE QUALQUER TIPO, expressas ou implícitas. Consulte a Licença para
o idioma específico que rege as permissões e limitações sob o

Licença. ================================================== ==========

"""Modelo de sequência a sequência com mecanismo de atenção."""

de importação futura absolute_import
da futura divisão de importação
da futura importação print_function

importar aleatório

importar numpy como np
from six.moves import xrange # pylint: disable=redefined-builtin
importe tensorflow como tf

importar dados_utils

class Seq2SeqModel(objeto):
"""Modelo de sequência a sequência com atenção e para vários baldes.

Esta classe implementa uma rede neural recorrente multicamada como codificador,
e um decodificador baseado em atenção. Este é o mesmo modelo descrito em
este artigo: http://arxiv.org/abs/1412.7449 - por favor, procure lá
detalhes,
ou na biblioteca seq2seq para implementação completa do modelo.
Esta classe também permite usar células GRU além das células LSTM, e
softmax amostrado para lidar com grande tamanho de vocabulário de saída. Uma camada única
versão deste modelo, mas com codificador bidirecional, foi apresentada em
http://arxiv.org/abs/1409.0473
e o softmax amostrado está descrito na Seção 3 do artigo a seguir.
http://arxiv.org/abs/1412.2007
"""

def init (auto,
source_vocab_size,
target_vocab_size,
baldes,
Tamanho,
num_camadas,
max_gradient_norm,
tamanho do batch,
taxa de Aprendizagem,
learning_rate_decay_factor,
use_lstm=Falso,
num_samples=512,
forward_only=Falso,
dtype=tf.float32):
"""Crie o modelo.

Args:
source_vocab_size: tamanho do vocabulário fonte.
target_vocab_size: tamanho do vocabulário alvo.
buckets: uma lista de pares (I, O), onde I especifica o comprimento máximo de entrada
que será processado nesse bucket e O especifica a saída máxima
comprimento. Instâncias de treinamento que têm entradas maiores que I ou saídas
maior que O será empurrado para o próximo balde e acolchoado de acordo.
Assumimos que a lista está ordenada, por exemplo, [(2, 4), (8, 16)].
tamanho: número de unidades em cada camada do modelo.
num_layers: número de camadas no modelo.
max_gradient_norm: os gradientes serão cortados ao máximo para esta norma.
batch_size: o tamanho dos lotes usados ​​durante o treinamento;
a construção do modelo é independente do batch_size, então pode ser
alterado após a inicialização se for conveniente, por exemplo, para decodificação.
learning_rate: taxa de aprendizado para começar.
learning_rate_decay_factor: diminui a taxa de aprendizado quando necessário.
use_lstm: se verdadeiro, usamos células LSTM em vez de células GRU.
num_samples: número de amostras para softmax amostrado.
forward_only: se definido, não construímos a passagem para trás no modelo.
dtype: o tipo de dados a ser usado para armazenar variáveis ​​internas.
"""
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), treinável=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, treinável=Falso)

Se usarmos softmax amostrado, precisamos de uma projeção de saída.

output_projection = Nenhum
softmax_loss_function = Nenhum

O softmax amostrado só faz sentido se amostrarmos menos do que o tamanho do vocabulário.

if num_samples > 0 e num_samples < self.target_vocab_size:
w_t = tf.get_variable("proj_w", [self.target_vocab_size, tamanho], dtype=dtype)
w = tf.transpose(w_t)
b = tf.get_variable("proj_b", [self.target_vocab_size], dtype=dtype)
projeção_saída = (w, b)

def sampled_loss(rótulos, entradas):
rótulos = tf.reshape(rótulos, [-1, 1])
# Precisamos calcular o sampled_softmax_loss usando floats de 32 bits para
# evitar instabilidades numéricas.
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),
tipo)
softmax_loss_function = sampled_loss

Crie a célula multicamada interna para nossa RNN.

def single_cell():
return tf.nn.rnn_cell.GRUCell(tamanho)
se usar_lstm:
def single_cell():
return tf.nn.rnn_cell.BasicLSTMCell(tamanho)
célula = single_cell()
se num_camadas > 1:
célula = tf.nn.rnn_cell.MultiRNNCell([single_cell() for _ in range(num_layers)])

A função seq2seq: usamos a incorporação para a entrada e atenção.

def seq2seq_f(encoder_inputs, decoder_inputs, do_decode):
return tf.contrib.legacy_seq2seq.embedding_attention_seq2seq(
encoder_inputs,
decoder_inputs,
célula,
num_encoder_symbols=source_vocab_size,
num_decoder_symbols=target_vocab_size,
embedding_size=tamanho,
output_projection=output_projection,
feed_previous=do_decode,
dtipo=dtipo)

Feeds para entradas.

self.encoder_inputs = []
self.decoder_inputs = []
self.target_weights = []
for i in xrange(buckets[-1][0]): # O último bucket é o maior.
self.encoder_inputs.append(tf.placeholder(tf.int32, shape=[None],
name="encoder{0}".format(i)))
para i em xrange(buckets[-1][1] + 1):
self.decoder_inputs.append(tf.placeholder(tf.int32, shape=[None],
nome="decodificador{0}".format(i)))
self.target_weights.append(tf.placeholder(dtype, shape=[None],
nome="peso{0}".formato(i)))

Nossos alvos são entradas do decodificador deslocadas em um.

alvos = [self.decoder_inputs[i + 1]
para i em xrange(len(self.decoder_inputs) - 1)]

Saídas e perdas de treinamento.

se forward_only:
self.outputs, self.losses = tf.contrib.legacy_seq2seq.model_with_buckets(
self.encoder_inputs, self.decoder_inputs, destinos,
self.target_weights, buckets, lambda x, y: seq2seq_f(x, y, True),
softmax_loss_function=softmax_loss_function)
# Se usarmos projeção de saída, precisamos projetar saídas para decodificação.
se output_projection não for None:
para b em xrange(len(buckets)):
self.outputs[b] = [
tf.matmul(saída, output_projection[0]) + output_projection[1]
para saída em self.outputs[b]
]
senão:
self.outputs, self.losses = tf.contrib.legacy_seq2seq.model_with_buckets(
self.encoder_inputs, self.decoder_inputs, destinos,
self.target_weights, buckets,
lambda x, y: seq2seq_f(x, y, False),
softmax_loss_function=softmax_loss_function)

Operação de atualização de gradientes e SGD para treinamento do modelo.

params = tf.trainable_variables()
se não for forward_only:
self.gradient_norms = []
self.updates = []
opt = tf.train.GradientDescentOptimizer(self.learning_rate)
para b em xrange(len(buckets)):
gradientes = tf.gradients(self.losses[b], params)
clipped_gradients, norma = tf.clip_by_global_norm(gradients,
max_gradient_norm)
self.gradient_norms.append(norm)
self.updates.append(opt.apply_gradients(
zip(clipped_gradients, params), global_step=self.global_step))

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

def step(self, session, encoder_inputs, decoder_inputs, target_weights,
bucket_id, forward_only):
"""Execute uma etapa do modelo alimentando as entradas fornecidas.

Args:
session: sessão tensorflow a ser usada.
encoder_inputs: lista de vetores numpy int para alimentar como entradas do codificador.
decoder_inputs: lista de vetores numpy int para alimentar como entradas do decodificador.
target_weights: lista de vetores float numpy para alimentar como pesos de destino.
bucket_id: qual bucket do modelo usar.
forward_only: se deve fazer o passo para trás ou apenas para frente.

Devoluções:
Um triplo consistindo em norma gradiente (ou Nenhum se não fizermos para trás),
perplexidade média, e as saídas.

Levanta:
ValueError: se comprimento de encoder_inputs, decoder_inputs ou
target_weights não concorda com o tamanho do bucket para o bucket_id especificado.
"""

Verifique se os tamanhos correspondem.

encoder_size, decoder_size = self.buckets[bucket_id]
if len(encoder_inputs) != encoder_size:
raise ValueError("O comprimento do codificador deve ser igual ao do bucket,"
" %d != %d." % (len(encoder_inputs), encoder_size))
if len(decoder_inputs) != decoder_size:
raise ValueError("O comprimento do decodificador deve ser igual ao do bucket,"
" %d != %d." % (len(decoder_inputs), decoder_size))
if len(target_weights) != decoder_size:
raise ValueError("O comprimento dos pesos deve ser igual ao do bucket,"
" %d != %d." % (len(target_weights), decoder_size))

Alimentação de entrada: entradas do codificador, entradas do decodificador, target_weights, conforme fornecido.

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

Como nossos alvos são entradas do decodificador deslocadas em um, precisamos de mais um.

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

Alimentação de saída: depende se fazemos um passo para trás ou não.

se não for forward_only:
output_feed = [self.updates[bucket_id], # Update Op que faz SGD.
self.gradient_norms[bucket_id], # Norma de gradiente.
self.losses[bucket_id]] # Perda para este lote.
senão:
output_feed = [self.losses[bucket_id]] # Perda para este lote.
for l in xrange(decoder_size): # Logits de saída.
output_feed.append(self.outputs[bucket_id][l])

outputs = session.run(output_feed, input_feed)
se não for forward_only:
return outputs[1], outputs[2], Nenhum # Norma de gradiente, perda, sem saídas.
senão:
return Nenhum, saídas[0], saídas[1:] # Nenhuma norma de gradiente, perda, saídas.

def get_batch(self, data, bucket_id):
"""Obtenha um lote aleatório de dados do bucket especificado, prepare-se para a etapa.

Para alimentar dados na etapa(..) deve ser uma lista de vetores de lote principal, enquanto
os dados aqui contêm casos principais de comprimento único. Então a lógica principal deste
função é reindexar os casos de dados para que estejam no formato adequado para alimentação.

Args:
data: uma tupla de tamanho len(self.buckets) na qual cada elemento contém
listas de pares de dados de entrada e saída que usamos para criar um lote.
bucket_id: integer, para qual bucket obter o lote.

Devoluções:
O triplo (encoder_inputs, decoder_inputs, target_weights) para
o lote construído que tem o formato adequado para chamar step(...) posteriormente.
"""
encoder_size, decoder_size = self.buckets[bucket_id]
encoder_inputs, decoder_inputs = [], []

Obtenha um lote aleatório de entradas de codificador e decodificador de dados,

preencha-os se necessário, inverta as entradas do codificador e adicione GO ao decodificador.

para _ em xrange(self.batch_size):
encoder_input, decoder_input = random.choice(data[bucket_id])

# As entradas do codificador são preenchidas e depois invertidas.
encoder_pad = [data_utils.PAD_ID] * (encoder_size - len(encoder_input))
encoder_inputs.append(list(reversed(encoder_input + encoder_pad)))

# As entradas do decodificador recebem um símbolo "GO" extra e são preenchidas então.
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)

Agora criamos vetores de lote principais a partir dos dados selecionados acima.

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

As entradas do codificador em lote são apenas codificadores_inputs reindexados.

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

As entradas do decodificador em lote são decoder_inputs reindexadas, criamos pesos.

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

# Crie target_weights para ser 0 para destinos que estão sendo preenchidos.
batch_weight = np.ones(self.batch_size, dtype=np.float32)
para batch_idx em xrange(self.batch_size):
# Definimos o peso como 0 se o alvo correspondente for um símbolo PAD.
# O alvo correspondente é decoder_input deslocado em 1 para frente.
if length_idx < decoder_size - 1:
target = decoder_inputs[batch_idx][length_idx + 1]
if length_idx == decoder_size - 1 ou 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`

—
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312679587 ,
ou silenciar o thread
https://github.com/notifications/unsubscribe-auth/ABtim0l5UMHHtbL1sz7meXserV8NVS7cks5sKQzXgaJpZM4MWl4f
.

ebrevdo picture ebrevdo em 3 jul. 2017
👍1

OK! obrigado mesmo assim! :)

sachinh35 picture sachinh35 em 3 jul. 2017

@ebrevdo existe alguma atualização de quando sairá o novo tutorial do seq2seq usando a nova api?
Obrigada. Ótimo trabalho!.

PratsBhatt picture PratsBhatt em 3 jul. 2017
👍1

sim esperando o novo tutorial... seria ótimo saber se está planejado para ser lançado em breve.. @ebrevdo

tentei pegar código nos testes do kernel e adaptar o beam search com o legado seq2seq, mas foi um desafio...

prashantserai picture prashantserai em 3 jul. 2017

Estamos torcendo para essa próxima semana!

Em 3 de julho de 2017 10h16, "prashantserai" [email protected] escreveu:

sim esperando o novo tutorial... seria ótimo saber se é
planejado para ser lançado em breve .. @ebrevdo
https://github.com/ebrevdo

tentou pegar o código nos testes do kernel e adaptar a busca de feixe com
o legado seq2seq, mas parecia desafiador...

—
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312697274 ,
ou silenciar o thread
https://github.com/notifications/unsubscribe-auth/ABtim45-HTuQrIRDhphqqHjqkKOKTe53ks5sKSHYgaJpZM4MWl4f
.

ebrevdo picture ebrevdo em 3 jul. 2017
👍5 ❤1

Oi pessoal,

Qualquer atualização para este problema, estou experimentando o mesmo no tensorflow 1.1-gpu para mac os x

tshi1983 picture tshi1983 em 20 jul. 2017

@tshi1983
Eu tenho o mesmo problema com o tensorflow 1.1-gpu para o Ubuntu.
Eu atualizo para o tf 1.2. Ainda não funciona.
Então eu mudo a função embedding_attention_seq2seq no arquivo
tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py
ao que o @fabiofumarola sugeriu acima.
Agora começa a treinar. Ainda não testei a decodificação.

selinachenxi picture selinachenxi em 24 jul. 2017

Mova o código na definição da célula para 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(
      ...
      )

Então "python translate.py --data_dir data/ --train_dir checkpoint/ --size=256 --num_layers=2 --steps_per_checkpoint=50" pode funcionar.

huxuanlai picture huxuanlai em 31 jul. 2017
👍12 🎉1

@huxuanlai funciona! Pelo menos está treinando agora, thx!

a111xushuai picture a111xushuai em 31 jul. 2017

@huxuanlai Funciona para mim também.

nathan-standafer picture nathan-standafer em 5 ago. 2017

Estou recebendo o mesmo AttributeError: 'NoneType' object has no attribute 'update' mas com tf.contrib.legacy_seq2seq.model_with_buckets . Estou executando o tf 1.2.1 (GPU) no Ubuntu 16.04 lts.

Isso só parece ocorrer quando eu tenho mais de 1 bucket.

rastreamento 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'
jkarimi91 picture jkarimi91 em 10 ago. 2017

@Tshzzz @jtubert
thx, sua solução funcionou para mim. Minha versão tf é 1.1.0.

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

para:

    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)
LevineHuang picture LevineHuang em 16 ago. 2017
❤2 👍2

Isso ainda não foi corrigido, tentei todas as soluções possíveis, mencionadas neste tópico e stackoverflow, não funciona com tensorflow 1.3 ou 1.2 ou 1.1

saurabhvyas picture saurabhvyas em 18 ago. 2017

Estou enfrentando este erro:
TypeError: embedding_attention_seq2seq() missing 1 required positional argument: 'dec_cell'

O erro aponta para esta função em seq2seq_model.py que é a linha 142 em 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)

Quem se deparou com este erro e conseguiu resolver isso, por favor me ajude a corrigir este problema.

comsian106 picture comsian106 em 18 ago. 2017
👍1

ValueError: Tentativa de reutilizar RNNCellcom um escopo de variável diferente do seu primeiro uso. O primeiro uso da célula foi com o escopo 'rnn/multi_rnn_cell/cell_0/gru_cell', esta tentativa é com o escopo 'rnn/multi_rnn_cell/cell_1/gru_cell'. Crie uma nova instância da célula se desejar que ela use um conjunto diferente de pesos. Se antes você estava usando: MultiRNNCell([GRUCell(...)] * num_layers), mude para: MultiRNNCell([GRUCell(...) for _ in range(num_layers)]). Se antes você estivesse usando a mesma instância de célula como célula direta e reversa de uma RNN bidirecional, basta criar duas instâncias (uma para encaminhamento e outra para reversão). Em maio de 2017, iniciaremos a transição do comportamento desta célula para usar os pesos armazenados existentes, se houver, quando ela for chamada com scope=None (o que pode levar à degradação silenciosa do modelo, portanto, esse erro permanecerá até então.)

o código de origem:
de tensorflow.contrib import rnn
inputs = tf.placeholder(dtype=tf.int32, shape=[None, None], name="inputs")
keep_prob = tf.placeholder(dtype=tf.float32, name="keep_prob")
célula = rnn.GRUCell(10)
cell = rnn.DropoutWrapper(cell=cell, input_keep_prob=keep_prob)
cell = rnn.MultiRNNCell([cell for _ in range(5)], state_is_tuple=True)

saídas, estados = tf.nn.dynamic_rnn(cell=cell, inputs=look_up, dtype=tf.float32)
solução:
inputs = tf.placeholder(dtype=tf.int32, shape=[None, None], name="inputs")
keep_prob = tf.placeholder(dtype=tf.float32, name="keep_prob")
cell = rnn.MultiRNNCell([rnn.DropoutWrapper(rnn.GRUCell(10), input_keep_prob=keep_prob) for _ in range(5)] , state_is_tuple=True)

ybdx picture ybdx em 25 ago. 2017
👍3

Você tem esse problema com o tf nightlies?

Em 1º de outubro de 2017 08:34, "Baohua Zhou" [email protected] escreveu:

Eu tenho o mesmo problema ao usar o tensorflow 1.1 na cpu com ios.

—
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-333384725 ,
ou silenciar o thread
https://github.com/notifications/unsubscribe-auth/ABtimwOv7vf5vvFXBllbZryjCFwmJcU6ks5sn7DxgaJpZM4MWl4f
.

ebrevdo picture ebrevdo em 1 out. 2017

AttributeError: o objeto 'NoneType' não tem atributo 'update'

em tf=1,3

PR-Iyyer picture PR-Iyyer em 23 out. 2017

ValueError: Tentativa de reutilizar RNNCellcom um escopo de variável diferente do seu primeiro uso. O primeiro uso da célula foi com o escopo 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_0/gru_cell', esta tentativa é com o escopo 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_1/gru_cell'. Crie uma nova instância da célula se desejar que ela use um conjunto diferente de pesos. Se antes você estava usando: MultiRNNCell([GRUCell(...)] * num_layers), mude para: MultiRNNCell([GRUCell(...) for _ in range(num_layers)]). Se antes você estivesse usando a mesma instância de célula como célula direta e reversa de uma RNN bidirecional, basta criar duas instâncias (uma para encaminhamento e outra para reversão). Em maio de 2017, iniciaremos a transição do comportamento desta célula para usar os pesos armazenados existentes, se houver, quando ela for chamada com scope=None (o que pode levar à degradação silenciosa do modelo, portanto, esse erro permanecerá até então.)

rashmishrm picture rashmishrm em 27 nov. 2017

Foram 14 dias sem atividade e o rótulo awaiting tensorflower foi atribuído. Atualize o rótulo e/ou status de acordo.

tensorflowbutler picture tensorflowbutler em 22 dez. 2017

Nagging Awaiting TensorFlower: Foram 14 dias sem atividade e o rótulo awaiting tensorflower foi atribuído. Atualize o rótulo e/ou status de acordo.

tensorflowbutler picture tensorflowbutler em 5 jan. 2018

A solução é mudar para uma versão mais recente do TF. Este tópico divergiu drasticamente de seu problema original. Fechamento.

ebrevdo picture ebrevdo em 5 jan. 2018

Se você quiser uma solução instantânea, tente o que eu tentei:

pip install tensorflow==1.0
O problema é com a versão 1.1 do tenorflow, funcionou para mim.

monk1337 picture monk1337 em 13 abr. 2018
Esta página foi útil?
0 / 5 - 0 avaliações

Questões relacionadas

ilblackdragon picture ilblackdragon  ·  3Comentários
waleedka picture waleedka  ·  3Comentários
ahmed-touati picture ahmed-touati  ·  3Comentários
MrSaad picture MrSaad  ·  3Comentários
jacobma-create picture jacobma-create  ·  3Comentários