tensorflow 🚀 - ValueError: 처음 사용한 것과 다른 변수 범위로 RNNCell을 재사용하려고 했습니다.

https://github.com/tensorflow/models/tree/master/tutorials/rnn/translate 에서 찾을 수 있는 번역 예제(작은 자체 테스트를 수행하는 경우에도)를 실행하려고 할 때 동일한 오류가 발생합니다.

ghost 에 2017년 03월 08일

👍22

나는 같은 문제를 만났다. 마스터 브랜치에서 모두 컴파일된 버전을 사용하고 계시다면 최근 commit 으로 인해 발생하는 동일한 문제라고 생각합니다. 커밋 메시지는 다음과 같이 말합니다.

tf.contrib.rnn의 모든 RNNCell이 tf.layers Layers처럼 작동하도록 하십시오.
여:
__call__을 처음 사용하면 사용한 범위가 셀에 저장됩니다. RNNCell은 해당 범위에서 가중치를 생성하려고 시도하지만 일부가 이미 설정된 경우 RNNCell이 인수 재사용=True로 구성되지 않은 경우 오류가 발생합니다.
동일한 셀 인스턴스의 __call__의 후속 사용은 동일한 범위에 있어야 합니다.
그렇지 않은 경우 오류가 발생합니다.

ptb tutorial 을 실행하는 제 경우에는 112번째 줄에 reuse 라는 이름의 매개변수를 추가하기만 하면 됩니다.

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

그러면 작동합니다.

tongda 에 2017년 03월 08일

👍28 ❤7 🎉7 😄5

@ebrevdo 이거 좀 봐주시겠어요 ?

prb12 에 2017년 03월 08일

Shakespeare RNN Repo 에서 Windows/GPU 빌드 105를 사용할 때 문제가 반복됩니다.

Win 1.0.0/GPU 릴리스로 코드를 실행할 때는 문제가 없습니다.

tomwanzek 에 2017년 03월 09일

그 저장소는 중간 릴리스가 아닌 tf 1.0을 대상으로 하는 것처럼 보입니다.

2017년 3월 8일 오후 3시 56분에 "Tom Wanzek" [email protected] 이 작성했습니다.

셰익스피어에서 Windows/GPU 빌드 105를 사용할 때 문제가 반복됩니다.
RNN 레포 https://github.com/martin-gorner/tensorflow-rnn-shakespeare .
Win 1.0.0/GPU 릴리스로 코드를 실행할 때는 문제가 없습니다.
—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285209555 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/ABtim5ansaL1KN51T4nCaqLnqw2QHN4Wks5rj0BBgaJpZM4MWl4f
.

ebrevdo 에 2017년 03월 09일

@tongda , 저는 CPU 모드의 MacOS에서 작동하는 Tensorflow 1.0 릴리스 버전을 사용하고 있습니다. "재사용" 매개변수를 추가하여 작동하는지 확인하기 위해 마스터 분기로 전환하겠습니다. 감사합니다.

doncat99 에 2017년 03월 09일

doncat99: 그렇게 하는 경우 코드가 tensorflow 버전을 쿼리하는지 확인하십시오.
버전이 마스터 분기 버전보다 낮으면 플래그를 발생시킵니다.
다음에 대해 확인해야 할 수도 있습니다.

tensorflow.core 가져오기 버전에서
버전.GIT_VERSION

2017년 3월 8일 수요일 오후 6시 58분에 doncat99 [email protected] 에서 다음과 같이 썼습니다.

@tongda https://github.com/tongda , 릴리스 버전을 사용하고 있습니다.
Tensorflow 1.0, CPU 모드의 MacOS에서 작동합니다. 마스터로 갈아타겠습니다
분기에 "재사용" 매개변수를 추가하여 작동하는지 확인하세요. 감사합니다.
—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285240438 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/ABtim66cU9e16lgD-2D0QLGcQCiHbV0zks5rj2rbgaJpZM4MWl4f
.

ebrevdo 에 2017년 03월 09일

@ebrevdo 그렇다면 셰익피어 RNN이 중간 안정 릴리스와 함께 작동할 수 있도록 하기 위해 제안된 변경 사항은 무엇입니까?

다음은 빌드#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

reuse 플래그에 관한 문서를 찾지 못한 것 같습니다.

미리 감사드립니다.

tomwanzek 에 2017년 03월 10일

사용:

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

각 레이어에 대해 별도의 그루셀 개체를 생성합니다.

2017년 3월 10일 오전 7시 44분에 "Tom Wanzek" [email protected] 이 작성했습니다.

@ebrevdo https://github.com/ebrevdo 그래서 제안되는 것은 무엇입니까
셰익피어 RNN이 중간체와 작동할 수 있도록 변경
안정적인 출시?
다음은 코드의 주요 아키텍처 섹션입니다. 이제 다음과 같이 실패합니다.
빌드#105:
모델(README.md의 FAQ 참조)
lr = tf.placeholder(tf.float32, name='lr') # 학습률
pkeep = tf.placeholder(tf.float32, name='pkeep') # 드롭아웃 매개변수
배치 크기 = tf.placeholder(tf.int32, 이름='배치 크기')
입력
X = tf.placeholder(tf.uint8, [없음, 없음], 이름='X') # [ BATCHSIZE, SEQLEN ]
Xo = tf.one_hot(X, ALPHASIZE, 1.0, 0.0) # [ BATCHSIZE, SEQLEN, ALPHASIZE ]# 예상 출력 = 다음 문자를 예측하려고 하기 때문에 동일한 시퀀스가 1만큼 이동됨
Y_ = tf.placeholder(tf.uint8, [없음, 없음], 이름='Y_') # [ BATCHSIZE, SEQLEN ]
Yo_ = tf.one_hot(Y_, ALPHASIZE, 1.0, 0.0) # [ BATCHSIZE, SEQLEN, ALPHASIZE ]# 입력 상태
Hin = tf.placeholder(tf.float32, [None, INTERNALSIZE*NLAYERS], name='Hin') # [ BATCHSIZE, INTERNALSIZE * NLAYERS]
NLAYERS=3개의 GRU 셀 레이어를 사용하여 전개된 SEQLEN=30회# dynamic_rnn은 입력 Xo의 크기에서 SEQLEN을 추론합니다.
onecell = rnn.GRUCell(INTERNALSIZE)
dropcell = rnn.DropoutWrapper(onecell, input_keep_prob=pkeep)
multicell = rnn.MultiRNNCell([범위 내 _에 대한 드롭셀(NLAYERS)], state_is_tuple=False)
multicell = rnn.DropoutWrapper(다중 셀, 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 ] # 마지막 상태입니다. 순서대로
재사용 플래그에 관한 문서를 찾지 못한 것 같습니까?
미리 감사드립니다.
—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285702372 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/ABtim6MOOCbx3RJEJe8PQBDXGVIXTGPmks5rkW_jgaJpZM4MWl4f
.

ebrevdo 에 2017년 03월 15일

seq2seq 자습서 모델 에서 이 오류가 발생하는 이유를 이해할 수 없습니다.

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

원천

셀이 생성되는 곳

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

BSVogler 에 2017년 03월 15일

👍20 😄1

@ebrevdo 이 문제에 대해 다시 알려주셔서 감사합니다. 불행히도 제안 된 변경 사항은 앞서 언급 한 오류와 함께 문제를 그대로 둡니다. seq2seq 튜토리얼 에 대한 위의 설명을 감안할 때 우리는 모두 같은 보트에 있다고 생각합니까?

tomwanzek 에 2017년 03월 15일

정확히 같은 오류라고 확신하십니까? 여기에 복사하여 붙여넣으십시오.

ebrevdo 에 2017년 03월 16일

내 나쁜, 나는 방금 관련 코드에 대한 변경 프로세스를 다시 (처음부터) 거쳤고 제안된 대로 다시 실행했습니다. 오류가 정말 제거되었고 이제 올드 바드가 환각을 하고 있습니다 👍

그래서, thx, 내가 어제 어디서 잘못했는지 확실하지 않지만 그것은 분명히 나에게 있었습니다.

tomwanzek 에 2017년 03월 16일

Tensorflow 1.0 릴리스 버전을 사용하고 MacOS에서 CPU 모드로 작업할 때도 동일한 문제가 발생했습니다. "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 에 2017년 03월 17일

다중 셀이 잘못된 것 같습니다... "cell() for _ in
범위(...)"

2017년 3월 16일 목요일 오후 8시 29분에 cuiming [email protected] 에서 다음과 같이 썼습니다.

Tensorflow 1.0 릴리스 버전을 사용할 때도 동일한 문제가 발생했습니다.
MacOS에서 CPU 모드로 작업합니다. "재사용" 매개변수를 추가하더라도
def 셀():
반환 tf.contrib.rnn.BasicLSTMCell(rnn_size,state_is_tuple=True,reuse=tf.get_variable_scope().reuse)
muticell = tf.contrib.rnn.MultiRNNCell([범위 내 _에 대한 셀(num_layers)], state_is_tuple=True)
—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-287257629 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/ABtim3A6JQr8ptRKrdiDW_kgNRIFkHGlks5rmf4WgaJpZM4MWl4f
.

ebrevdo 에 2017년 03월 17일

번역 예제를 실행하려고 했습니다. python2.7 translate.py --data_dir data/ --train_dir train/ --size=256 --num_layers=2 --steps_per_checkpoint=50

MultiRNNCell을 사용하는 방법이 올바른 것 같습니다.
cell = tf.contrib.rnn.MultiRNNCell([single_cell() for _ in range(num_layers)])

하지만 같은 오류가 발생했습니다.
ValueError: RNNCell 재사용 시도첫 번째 사용과 다른 변수 범위를 사용합니다. 셀의 첫 번째 사용은 범위 'embedding_attention_seq2seq/embedding_attention_decoder/attention_decoder/multi_rnn_cell/cell_0/gru_cell'이었고, 이 시도는 범위 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_0/gru_cell'입니다. 다른 가중치 세트를 사용하려면 셀의 새 인스턴스를 만드십시오. 이전에 MultiRNNCell([GRUCell(...)] * num_layers)을 사용했다면 MultiRNNCell([GRUCell(...) for _ in range(num_layers)])로 변경합니다. 양방향 RNN의 순방향 및 역방향 셀 모두와 동일한 셀 인스턴스를 사용하기 전에 두 개의 인스턴스를 생성하기만 하면 됩니다(하나는 정방향, 하나는 역방향). 2017년 5월에 scope=None(자동 모델 저하로 이어질 수 있으므로 이 오류는 그때까지 유지됨)으로 호출될 때 기존에 저장된 가중치를 사용하도록 이 셀의 동작을 전환하기 시작할 것입니다.

bowu 에 2017년 03월 26일

👍10

@bowu - 운이 좋았습니까? 아직 시도하지 않았다면 최신 소스에서 tensorflow를 다시 설치하십시오. core_rnn 파일 중 일부가 일부 변경되었습니다. 지금 나를 위해 작동합니다.

robmsylvester 에 2017년 03월 29일

@robmsylvester 최신 소스에서 tensorflow를 다시 설치했지만 여전히 동일한 오류입니다. 나는 지점 마스터에 있었고 최신 커밋은 commit 2a4811054a9e6b83e1f5a2705a92aab50e151b13 입니다. 리포지토리를 구축할 때 가장 최근에 커밋한 내용은 무엇입니까?

oxwsds 에 2017년 03월 30일

안녕하세요, 저는 소스를 사용하여 빌드된 GPU를 사용하여 Tensorflow r1.0을 사용하고 있습니다. 수정되지 않은 Seq2Seq 번역 자습서를 따르려고 하지만 동일한 오류가 발생합니다. 즉

ValueError: RNNCell 재사용 시도첫 번째 사용과 다른 변수 범위를 사용합니다. 셀의 첫 번째 사용은 범위 'embedding_attention_seq2seq/embedding_attention_decoder/attention_decoder/multi_rnn_cell/cell_0/gru_cell'이었고, 이 시도는 범위 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_0/gru_cell'.....

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

문제를 해결하려면 어떻게 해야 합니까?

GRUCell이 생성되는 호출에 "reuse=tf.get_variable_scope().reuse"를 추가해도 도움이 되지 않습니다.

엄청 고마워!

prashantserai 에 2017년 04월 03일

👍5

@prashantserai - 위에서 MultiRNNCell 라인을 제거하여 네트워크를 하나의 레이어로 효과적으로 만드는 경우 어떤 일이 발생하는지 확인하십시오. 그러면 작동합니까? MultiRNNCell의 어딘가에 버그가 있을 수 있습니다. 나는 최근 어딘가에서 아마도 스택 오버플로에 대해 읽었습니다.

스택형 lstm/gru를 직접 구현하면 이 오류가 발생하지 않고 동일한 기능을 구현할 수 있습니다(실제로 더 많이, 양방향 아키텍처, 이상한 잔여 및 건너뛰기 연결 등으로 원하는 모든 작업을 자유롭게 수행할 수 있기 때문에). .)

robmsylvester 에 2017년 04월 04일

@robmsylvester num_layers=1로 시도했는데도 동일한 오류가 지속되어 해당 줄을 효과적으로 건너뛸 수 있었습니다. 다른 아이디어가 있습니까? 입력해 주셔서 감사합니다.

prashantserai 에 2017년 04월 04일

👍3 👎1

흠. 나에게 눈에 띄는 한 가지는 참조된 레거시 seq2seq 파일에 있습니다.

encoder_cell = copy.deepcopy(cell)

인코더 측과 디코더 측 모두에서 동일한 아키텍처가 사용되기 때문에 이 라인이 사용된 것으로 보입니다. 그들은 셀의 복사본을 만든 다음 셀 인수를 어텐션 디코더 임베딩 함수와 함께 전달한 다음 어텐션 디코더 자체로 전달합니다.

seq2seq 모델 파일에 인코더 셀과 디코더 셀을 명시적으로 생성하고 둘 다 레거시 라이브러리 파일에 전달하여 함수와 해당 인수를 약간 조정하면 어떻게 됩니까?

robmsylvester 에 2017년 04월 04일

👍1

@robmsylvester 가 작동하는 셀 범위를 변경해서는 안 됩니까? 다른 두 가지 예에서도 작동합니다. 제 생각에는 이것은 매우 추악한 해결 방법이 될 것입니다. 더 깨끗한 솔루션이 있어야 합니다. 어쩌면 우리가 뭔가를 놓치고 있습니까? ( seq2seq 튜토리얼에서도 동일한 오류가 발생하여 위의 모든 솔루션을 시도했습니다.)

iamgroot42 에 2017년 04월 04일

@iamgroot42 - 예, 그 '해결책'은 분명히 매우 추악하지만 문제가 있을 수 있는 위치를 찾으려고 하는 것이 더 그렇습니다. 나는 몇 시간 후에 그것을 가지고 놀고 내가 무언가를 추적할 수 있는지 볼 것입니다.

robmsylvester 에 2017년 04월 04일

사실 copy.deepcopy는 레거시 함수이기 때문에 존재합니다.
유지/업데이트할 리소스가 없습니다. 원하는 경우
사용자가 제공할 수 있는 이전 버전과 호환되는 변경을 도입
디코딩 단계를 위한 두 번째 셀, 그리고 None이면 대체
deepcopy, 그러면 PR을 검토하게 되어 기쁩니다. 할 것이라는 것을 명심하십시오
이전 버전과 호환되는 변경 사항이어야 합니다.

2017년 4월 4일 화요일 오전 11:38, Rob Sylvester [email protected]
썼다:

@iamgroot42 https://github.com/iamgroot42 - 네, 그 '해결책'은
분명히 매우 추악하지만 문제가 있는 위치를 찾으려고 하는 경우에는 더욱 그렇습니다.
아마도. 나는 몇 시간 후에 그것을 가지고 놀고 내가 뭔가를 추적할 수 있는지 볼 것입니다
아래에.
—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-291593289 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/ABtim1QHTDhOC_zT6cKtmUFPOit5Yjn7ks5rso5CgaJpZM4MWl4f
.

ebrevdo 에 2017년 04월 06일

@ebrevdo - 생각해볼게요. 나는 이것과 매우 유사하게 작동하지만 원하는 곳에 양방향 레이어를 삽입할 수 있는 별도의 클래스를 통해 셀을 생성하고, 원하는 곳에 잔차를 삽입하고, 입력을 concat 대 합계로 병합하는 등의 몇 가지 다른 번역기를 가지고 있습니다. 정적 RNN을 사용하여 이 튜토리얼로 내 클래스를 아주 쉽게 마이그레이션할 수 있다고 생각합니다. 내가 알려 주마.

robmsylvester 에 2017년 04월 06일

@ebrevdo 저는 Red Hat에서 Tensorflow r1.0(tensorflow-1.0.1-cp36-cp36m-linux_x86_64)을 실행 중이며 Github에서 최신 버전의 번역 튜토리얼을 가지고 있습니다. 현재 이 작업을 수행할 수 있는 방법이 있습니까?

prashantserai 에 2017년 04월 06일

번역 튜토리얼이 TF 1.0에서 작동하지 않는 것은 유감입니다. 우리는 그것을 수정해야합니다. @lukaszkaiser 좀 봐주시겠어요 ? 우리는 새로운 튜토리얼을 작업 중이지만 아직 몇 주 남았고 작동하려면 야간 버전의 TensorFlow(또는 TF 1.1 또는 1.2)가 필요합니다.

ebrevdo 에 2017년 04월 06일

(lukasz; TF 1.0에서 튜토리얼의 어느 부분에 결함이 있는지 다양한 의견에서 식별하기가 어렵습니다. 라인을 식별할 수 있고 작동하도록 도울 수 있는 기회가 있습니까?)

ebrevdo 에 2017년 04월 06일

@ebrevdo 이 튜토리얼입니다. 이 라인 클러스터에 오류가 있습니다. 여기에 전달된 셀은 레거시 seq2seq 모델의 역방향 및 순방향 단계 모두에 사용되며, 동일한 셀이 다른 범위에서 사용되기 때문에 오류가 발생합니다.

iamgroot42 에 2017년 04월 06일

@iamgroot42 필요한 변경 사항으로 홍보하시겠습니까? 그것은 좋을 것입니다. 나는 현재 스스로 그것을 할 수 있는 주기가 없습니다. 감사 해요!

lukaszkaiser 에 2017년 04월 06일

나는 TF 1.0이 remotes/origin/r1.0 브랜치의 소스에서 컴파일된 경우 최신 버전의 번역 튜토리얼에서 잘 작동한다는 것을 알아차렸습니다.

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

그런 다음 TensorFlow를 빌드하고 설치하면 잘 작동합니다.

remotes/origin/r1.1 분기에는 "다른 변수 범위" 오류가 있습니다.
@robmsylvester 가 제안한 대로 코드를 수정했습니다.

seq2seq 모델 파일에 인코더 셀과 디코더 셀을 명시적으로 생성하고 둘 다 레거시 라이브러리 파일에 전달하여 함수와 해당 인수를 약간 조정하면 어떻게 됩니까?

그리고 그것은 지금 나를 위해 작동합니다.

oxwsds 에 2017년 04월 06일

👍1

@oxwsds 내가 사용하는 Tensorflow는 1.0.1이므로 오류가 있을 수 있습니다.

@robmsylvester 가 실제로 제안한 것을 시도했습니다. 그리고 교육이 시작되었습니다(2일 13시간 완료).. 디코딩하는 동안 오류와 함께 실패합니다.

  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)

디코딩을 시도 했습니까?

prashantserai 에 2017년 04월 08일

@prashantserai 정확히는 모르겠지만 만나본 내용은 다른 문제인 것 같습니다.

oxwsds 에 2017년 04월 10일

@prashantserai 디코딩할 때만 실패하면 배치 크기 1을 사용하는 것과 관련이 있습니까? 훈련 중에 배치 크기를 1로 낮추면 모델이 계속 훈련됩니까?

robmsylvester 에 2017년 04월 10일

@bowu 여기에 같은 오류가 있습니다. Mac OX 시에라, TensorFlow 1.1.0-rc1, Python 2.7.10 및 Python 3.6.1.

soloice 에 2017년 04월 10일

@robmsylvester 그것은 배치 크기도 1로 성공적으로 훈련했지만 같은 방식이나 유사한 방식으로 디코딩하는 동안 실패했습니다. 여기에 전체 역추적이 있습니다.. 내가 이것을 연결된 오류로 생각한 이유는 에 대한 참조 때문이었습니다. seq2seq_f(수정된 함수 중 하나)(수정된 줄을 나타내는 #prashant 주석은 추적의 일부임)

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 위의 전체 추적을 기반으로 귀하의 의견이 변경됩니까?

prashantserai 에 2017년 04월 10일

@prashantserai 디코딩을 시도했는데 잘 작동합니다. encoder_cell arg 를 tf.contrib.legacy_seq2seq.embedding_attention_seq2seq 함수에 추가하고 $ translate/seq2seq_model.py 에서 셀을 만들고 seq2seq_f 함수에서 호출된 함수에 전달합니다. 코드를 어떻게 변경했습니까?

oxwsds 에 2017년 04월 11일

👍1

@ssssss @robmsylvester @ebrevdo
마침내 지금 작동하는 것이 있습니다(제 단일 레이어 256 단위 네트워크에 대한 결과는 일종의 끔찍하지만 그것은 아마도 네트워크가 초경량이고 매개변수를 전혀 조정하지 않았기 때문일 것입니다)
여러분 정말 감사합니다...!!!!!

_마지막에 제 생각은 이렇습니다._

@oxwsds 는 Tensorflow가 remotes/origin/r1.0 브랜치에서 컴파일될 때 수정이 필요 없이 튜토리얼(현재 형식)이 TRUE 라고 설명합니다 . 그러나 슬픈 비트는 내가 가지고 있는 Tensorflow 코드 내에서 수정이 필요한 Tensorflow 버전과 remotes/origin/r1.0의 버전이 모두 동일하게 레이블이 지정되었다는 것입니다.

주석에서 @robmsylvester 의 수정 사항(아래에 복사됨)은 Tutorial이 기본적으로 작동하지 않는 내 버전의 Tensorflow에서 작동했습니다(TF 1.1에서도 작동해야 한다고 생각합니다). 구현하기가 약간 지저분하지만 할 수 있습니다. 즉, 뭔가를 말하고 있습니다 :-P
이 전에 내 마지막 두 댓글의 오류는 내 실수로 인한 것입니다. 더미처럼 훈련 중에만 레이어와 은닉 유닛 매개변수를 지정하고 디코딩하는 동안 기본값을 사용하도록 코드를 그대로 두었습니다. (튜토리얼의 이 부분은 약간 더 더미 증거가 될 수 있습니다: https://www.tensorflow.org/tutorials/seq2seq#lets_run_it )

흠. 나에게 눈에 띄는 한 가지는 참조된 레거시 seq2seq 파일에 있습니다.
인코더_셀 = copy.deepcopy(셀)
인코더 측과 디코더 측 모두에서 동일한 아키텍처가 사용되기 때문에 이 라인이 사용된 것으로 보입니다. 그들은 셀의 복사본을 만든 다음 셀 인수를 어텐션 디코더 임베딩 함수와 함께 전달한 다음 어텐션 디코더 자체로 전달합니다.
seq2seq 모델 파일에 인코더 셀과 디코더 셀을 명시적으로 생성하고 둘 다 레거시 라이브러리 파일에 전달하여 함수와 해당 인수를 약간 조정하면 어떻게 됩니까?

prashantserai 에 2017년 04월 11일

👍1

피드백 감사드립니다! TF마다 뭔가 다른게 보이네요.
pypi와 해당 태그에서? 건한, 그게 가능해?

2017년 4월 10일 월요일 오후 9:05 prashantserai [email protected]
썼다:

@oxwsds https://github.com/oxwsds @robmsylvester
https://github.com/robmsylvester @ebrevdo https://github.com/ebrevdo
나는 마침내 지금 작동하는 무언가를 가지고 있습니다 (내 말은, 내 싱글에 대한 결과
레이어 256 단위 네트워크는 일종의 끔찍하지만 아마도
네트워크가 초경량이고 매개변수를 전혀 조정하지 않았기 때문에)
내 결론은 다음과 같습니다.
@oxwsds https://github.com/oxwsds 는 튜토리얼이현재 형식) Tensorflow가 있을 때 수정할 필요 없이 작동합니다.remotes/origin/r1.0 브랜치에서 컴파일된 것은 TRUE 입니다. 슬픈 비트
내가 수정한 Tensorflow 버전이지만
Tensorflow 코드 내에서 필요했으며 remotes/origin/r1.0의 버전
둘 다 동일하게 표시되었습니다.
@robmsylvester https://github.com/robmsylvester 의 댓글 수정
(아래에 복사) 자습서가 있는 Tensorflow 버전에서 작동했습니다.
기본적으로 작동하지 않았습니다(TF 1.1에서도 작동해야 합니다). 그것은
구현하기가 약간 지저분하지만 할 수 있습니다.
:-피
이 전에 내 마지막 두 댓글의 오류는 내 실수로 인한 것입니다. 좋다
더미, 나는 레이어와 은닉 유닛 매개변수만 지정하고 있었습니다.
훈련 중에 디코딩하는 동안 기본값을 사용하도록 코드를 그대로 두었습니다. (이것튜토리얼의 일부는 약간 더 더미 증거가 될 수 있습니다.https://www.tensorflow.org/tutorials/seq2seq#lets_run_ithttps://www.tensorflow.org/tutorials/seq2seq#lets_run_it )
흠. 나에게 눈에 띄는 한 가지는 참조된 레거시 seq2seq
파일:
인코더_셀 = copy.deepcopy(셀)
동일한 아키텍처가 양쪽 모두에서 사용되기 때문에 이 라인이 사용되는 것으로 보입니다.
인코더 및 디코더 측. 그들은 셀의 사본을 만든 다음 전달합니다.
어텐션 디코더 임베딩 기능과 함께 셀 인수, 다음으로
주의 디코더 자체.
인코더 셀과 디코더를 명시적으로 생성하면 어떻게 됩니까?
seq2seq 모델 파일의 셀을 만들고 둘 다 레거시 라이브러리에 전달합니다.
파일, 함수 및 해당 인수를 약간 조정합니까?
—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-293143828 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/ABtimxvcfFnbWbpj7aUs3BUjwGEFj6p5ks5ruvvygaJpZM4MWl4f
.

ebrevdo 에 2017년 04월 11일

정보를 위해 LSTM 셀을 쌓는 동안 이 문제가 발생했습니다.
내 원래 코드는 다음과 같습니다.

    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)

그런 다음 다음 코드로 모델을 만드는 것은 괜찮았지만 다른 모델과 변수를 공유할 수 없었습니다. (예를 들어 텐서를 공유해야 하는 train_model 및 valid_model을 생성하면 실패합니다)

    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)

그래서 마지막으로 lstm_creator 를 tensorflow/models/tutorials/rnn/ptb/ptb_word_lm.py#L112 에서 lstm_cell 와 같은 함수로 사용했습니다. 나는 지금 가지고있다 :

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)

이제 완전히 작동합니다.

pltrdy 에 2017년 04월 13일

👍3

이 작업을 실행하려고 하면 동일한 오류가 발생합니다.

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

@pltrdy 의 솔루션은 이상하게 나를 위해 그것을하지 않았습니다. 나는 점점

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 에 2017년 04월 16일

@aep 는 https://github.com/tensorflow/models/blob/master/tutorials/rnn/ptb/ptb_word_lm.py#L112 의 기능을 사용하셨습니까? 내 게시물 끝에서 언급한(이제 더 명확하게 편집 )

pltrdy 에 2017년 04월 18일

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

그것은 내 문제를 해결했다

Tshzzz 에 2017년 04월 28일

이전 버전의 Tensorflow를 설치하여 이 문제를 해결했습니다.
pip install -Iv tensorflow==1.0

seq2seq 튜토리얼을 실행할 때 오류가 발생했습니다.

dsoiM 에 2017년 04월 28일

👍10 ❤1 🎉1

@ebrevdo 가 말한 것과 관련하여 솔루션은 레거시 seq2seq 코드를 수정하는 것이 아니라 적극적으로 유지 관리되는 contrib.seq2seq 패키지를 대신 사용하도록 자습서를 업데이트하는 것이라고 생각합니다. 처음으로 실행한 tensorflow 프로그램이 많은 오류를 뱉어내는 것은 매우 사기를 저하시킵니다. 이번 주에 시간이 되면 PR을 제출하겠습니다.

kyteague 에 2017년 05월 01일

👍2

우리는 새로운 seq2seq 튜토리얼을 진행 중입니다. 우리는 말까지 출시되기를 바랐습니다.
지난 달이지만 지연되고 있습니다. 새 API를 사용합니다.

2017년 5월 1일 오전 8시 7분에 "Kyle Teague" [email protected] 이 작성했습니다.

@ebrevdo https://github.com/ebrevdo 가 말한 것과 관련하여 제 생각에는
해결책은 레거시 seq2seq 코드를 수정하는 것이 아니라 업데이트하는 것입니다.
대신 적극적으로 contrib.seq2seq 패키지를 사용하는 자습서
유지. 처음 tensorflow 프로그램을 시작할 때 매우 사기를 떨어뜨립니다.
이제까지 실행하면 많은 오류가 발생합니다. 이번 주에 시간이 된다면
PR을 제출합니다.
—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-298350307 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/ABtim587xZx9Gi4-yXmwccSum8_Trc1oks5r1fUogaJpZM4MWl4f
.

ebrevdo 에 2017년 05월 01일

@ebrevdo tensorflow1.1 웹사이트에서 sequence_to_sequence 모델을 실행할 때도 동일한 오류가 발생합니다. 그리고 'use' 매개변수를 사용하려고 했지만 실패했습니다. 새로운 seq2seq 튜토리얼이 언제 출시되는지 알려주시겠습니까?

njuzrs 에 2017년 05월 05일

tf 1.2와 동시에 보입니다. 왜냐하면 우리는 새로운
해당 릴리스의 기능.

2017년 5월 4일 오후 9시 16분에 "njuzrs" [email protected] 이 작성했습니다.

@ebrevdo https://github.com/ebrevdo 실행할 때 동일한 오류가 발생합니다
tensorflow1.1 웹사이트의 sequence_to_sequence 모델. 그리고 나는 시도했다
'재사용' 매개변수를 사용했지만 실패했습니다. 새로운 seq2seq가 언제인지 알려주시겠습니까?
튜토리얼이 공개되나요?
—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-299366774 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/ABtim8_kFTM7-SsXQAA-Ar0dfhHMGT0Zks5r2qKngaJpZM4MWl4f
.

ebrevdo 에 2017년 05월 05일

@ebrevdo 저도 같은 문제에 직면해 있으며 seq2seq로 진행할 수 없습니다. 새 튜토리얼의 가능한 날짜를 알려주시면 정말 도움이 될 것입니다.
도와 주셔서 정말로 고맙습니다.

PratsBhatt 에 2017년 05월 08일

👍7

pip install tensorflow==1.0 (Tensorflow 1.0)을 사용하여 설치하는 것이 효과적입니다(튜토리얼 번역).

tanmayb123 에 2017년 05월 09일

버전 1.1.0-rc2가 있습니다.

PratsBhatt 에 2017년 05월 09일

TF1.2가 이 문제를 해결할까요? 모델 교육을 계속하는 방법을 알려주세요. TF 1.0은 작동하지만 여러 GPU에 대한 devicewrapper API가 없습니다.

MingCong18 에 2017년 05월 15일

텐서 흐름 1.1과 동일한 문제가 있습니다. 여전히 솔루션 작업 중

thomasqjohns 에 2017년 05월 19일

여러 가지를 시도했지만 결국 tensorflow 1.1을 사용할 수 있었지만 다음과 같이 변경해야 했습니다. (위의 Tshzzz 기반)

이것을 제거하십시오:
multicell = rnn.MultiRNNCell([dropcell]*NLAYERS, state_is_tuple=False)

그리고 이것을 추가하십시오:
셀=[]
_ 범위 내(NLAYERS):
셀 = rnn.DropoutWrapper(tf.contrib.rnn.GRUCell(INTERNALSIZE), input_keep_prob=pkeep)
cells.append(셀)
multicell = rnn.MultiRNNCell(셀, state_is_tuple=False)

jtubert 에 2017년 05월 20일

👍3

@ebrevdo 축하합니다. TF 1.2가 방금 출시되었습니다. 새 튜토리얼도 어딘가에 출시되었나요? 아니면 곧 출시될 예정인가요?

감사 해요

prashantserai 에 2017년 05월 20일

출시되면 공지할 예정입니다. 작업 중입니다.

2017년 5월 19일 오후 7시 2분에 "prashantserai" [email protected] 이 작성했습니다.

@ebrevdo https://github.com/ebrevdo 축하합니다. TF 1.2가 나왔습니다.
출시됨 - 새 튜토리얼도 어딘가에 출시되었습니까?
곧 출시?
감사 해요
—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-302844002 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/ABtim0RWDzNCXk-bIjKSyHLvgFxUvq2lks5r7km7gaJpZM4MWl4f
.

ebrevdo 에 2017년 05월 20일

👍2

tensorflow-gpu==1.1.0을 사용하고 이 오류가 발생하는 사람은 pip install tensorflow-gpu==1.0.0을 통해 1.0.0으로 전환해도 문제가 해결되지 않습니다. 적어도 저에게는 효과가 없었습니다.

나는 mac과 ubuntu 모두에서 이 문제에 부딪쳤고 소스에서 컴파일하는 것이 두 번 모두 작동했습니다. 그래서:
핍 설치 https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.0.0-cp34-cp34m-linux_x86_64.whl

ajaanbaahu 에 2017년 05월 24일

@ajaanbaahu 여전히 tf1.2 새로운 seq2seq 튜토리얼을 기다리고 있습니다.

MingCong18 에 2017년 05월 25일

👍3

pip install tensorflow==1.0 을 사용하여 저에게 효과적이었습니다.

saching270 에 2017년 05월 26일

tf r1.2의 경우 deepcopy 오류가 발생했습니다. 모델 오류 #1050을 순서 대로 나열한 대로

Vimos 에 2017년 05월 26일

신인으로서 제 의견을 좀 올립니다.
다음 코드는 이와 유사한 실수를 발생시킵니다.
(내 코드의 일부)

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)

다음과 같은 오류 덤프:

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

그러나 수정 작업을 수행한 후에는 작동할 수 있습니다.

"""
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 에 2017년 05월 29일

이러한 해결 방법 중 어느 것도 Tensorflow 1.1에서 작동하지 않았습니다.

MultiRNNCell 셀이 있는 seq2seq 모델을 사용하고 있습니다.

나는 1.0.1로 되돌아가야 했다: pip3 install tensorflow==1.0

philipperemy 에 2017년 06월 02일

👍6

legacy_seq2seq.rnn_decoder()로 작업할 때 이러한 문제가 있는 사람이 있습니까?

rileyedmunds 에 2017년 06월 06일

@oxwsds 말씀하신 대로 tf.contrib.legacy_seq2seq.embedding_attention_seq2seq의 입력 인수 셀을 두 개의 다른 셀 {encoder_cells, decoder_cells}로 변경합니다. 마지막으로 seq2seq 모델이 작동합니다. 73200 setps 후에 당혹도 5.54를 얻습니다.
그런 다음 디코딩 부분을 실행합니다.

미국 대통령은 누구입니까?
Qui est le président des États-Unis?

문제 해결됨. 감사 해요.

supermeatboy82 에 2017년 06월 07일

@doncat99
seq2seq.py 의 copy.deepcopy(cell) $이(가) 적용되지 않는 것 같습니다.
따라서 seq2seq_model.py 의 관련 부분을 다음으로 변경합니다.

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 에 2017년 06월 15일

👍2

@supermeatboy82 , 코드를 공유할 수 있습니까?

martinambition 에 2017년 06월 19일

Tensorflow 1.2.0으로 업그레이드하고 목록 곱셈 대신 루프에서 셀을 생성하면 이 문제가 해결되었습니다.

cpury 에 2017년 06월 21일

translate.py를 실행할 때 TF1.2에 오류가 발생했습니다. 세부 정보:
이름: 지포스 GTX 1080 Ti
메이저: 6 마이너: 1 memoryClockRate(GHz) 1.582
pci버스ID 0000:02:00.0
총 메모리: 10.91GiB
여유 메모리: 10.76GiB
2017-06-22 09:15:04.485252: I tensorflow/core/common_runtime/gpu/gpu_device.cc:961] DMA: 0
2017-06-22 09:15:04.485256: I tensorflow/core/common_runtime/gpu/gpu_device.cc:971] 0: Y
2017-06-22 09:15:04.485265: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1030] TensorFlow 장치 생성(/gpu:0) -> (장치: 0, 이름: GeForce GTX 1080 Ti, pci 버스 ID: 0000:02:00.0)
1024 유닛의 3개의 레이어를 생성합니다.
역추적(가장 최근 호출 마지막):
파일 "translate.py", 322행,
tf.app.run()
파일 "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/python/platform/app.py", 48행, 실행 중
_sys.exit(main(_sys.argv[:1] + flags_passthrough))
파일 "translate.py", 319행, 메인
기차()
기차에서 파일 "translate.py", 178행
모델 = create_model(sess, False)
create_model의 파일 "translate.py", 136행
dtype=dtype)
파일 "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", 179행, __init__
softmax_loss_function=softmax_loss_function)
model_with_buckets의 파일 "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", 1206행
디코더_입력[:버킷[1]])
파일 "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", 라인 178, in
람다 x, y: seq2seq_f(x, y, False),
파일 "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", 142행, seq2seq_f
dtype=dtype)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", 848행, embedding_attention_seq2seq
인코더_셀 = copy.deepcopy(셀)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 174행, deepcopy
y = 복사기(메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/python/layers/base.py", 476행, __deepcopy__
setattr(결과, k, copy.deepcopy(v, 메모))
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 163행, deepcopy
y = 복사기(x, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 230행, _deepcopy_list
y.append(deepcopy(a, 메모))
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 190행, deepcopy
y = _reconstruct(x, rv, 1, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 334행, _reconstruct
상태 = deepcopy(상태, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 163행, deepcopy
y = 복사기(x, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 257행, _deepcopy_dict
y[deepcopy(키, 메모)] = deepcopy(값, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 190행, deepcopy
y = _reconstruct(x, rv, 1, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 334행, _reconstruct
상태 = deepcopy(상태, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 163행, deepcopy
y = 복사기(x, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 257행, _deepcopy_dict
y[deepcopy(키, 메모)] = deepcopy(값, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 190행, deepcopy
y = _reconstruct(x, rv, 1, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 334행, _reconstruct
상태 = deepcopy(상태, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 163행, deepcopy
y = 복사기(x, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 257행, _deepcopy_dict
y[deepcopy(키, 메모)] = deepcopy(값, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 190행, deepcopy
y = _reconstruct(x, rv, 1, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 334행, _reconstruct
상태 = deepcopy(상태, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 163행, deepcopy
y = 복사기(x, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 257행, _deepcopy_dict
y[deepcopy(키, 메모)] = deepcopy(값, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 163행, deepcopy
y = 복사기(x, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 257행, _deepcopy_dict
y[deepcopy(키, 메모)] = deepcopy(값, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 163행, deepcopy
y = 복사기(x, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 230행, _deepcopy_list
y.append(deepcopy(a, 메모))
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 190행, deepcopy
y = _reconstruct(x, rv, 1, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 334행, _reconstruct
상태 = deepcopy(상태, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 163행, deepcopy
y = 복사기(x, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 257행, _deepcopy_dict
y[deepcopy(키, 메모)] = deepcopy(값, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 190행, deepcopy
y = _reconstruct(x, rv, 1, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 334행, _reconstruct
상태 = deepcopy(상태, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 163행, deepcopy
y = 복사기(x, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 257행, _deepcopy_dict
y[deepcopy(키, 메모)] = deepcopy(값, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 190행, deepcopy
y = _reconstruct(x, rv, 1, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 334행, _reconstruct
상태 = deepcopy(상태, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 163행, deepcopy
y = 복사기(x, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 257행, _deepcopy_dict
y[deepcopy(키, 메모)] = deepcopy(값, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 163행, deepcopy
y = 복사기(x, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 230행, _deepcopy_list
y.append(deepcopy(a, 메모))
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 163행, deepcopy
y = 복사기(x, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 237행, _deepcopy_tuple
y.append(deepcopy(a, 메모))
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 163행, deepcopy
y = 복사기(x, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 257행, _deepcopy_dict
y[deepcopy(키, 메모)] = deepcopy(값, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 190행, deepcopy
y = _reconstruct(x, rv, 1, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 334행, _reconstruct
상태 = deepcopy(상태, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 163행, deepcopy
y = 복사기(x, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 257행, _deepcopy_dict
y[deepcopy(키, 메모)] = deepcopy(값, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 190행, deepcopy
y = _reconstruct(x, rv, 1, 메모)
파일 "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", 343행, _reconstruct
y.__dict__.update(상태)
AttributeError: 'NoneType' 개체에 '업데이트' 속성이 없습니다.

syw2014 에 2017년 06월 22일

튜토리얼의 번역 모델에서 self_test() 를 실행할 때 embedding_attention_seq2seq() copy.deepcopy(cell) 로 인한 오류도 만났습니다.
Seq2SeqModel seq2seq_f() 의 코드를 다음과 같이 변경하려고 했습니다.

    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)

그러면 이제 오류가 없습니다.
그러나 신인으로서 여기 코드가 이전과 같이 작동하는지 여부를 알지 못하며 변경 사항으로 인해 모델이 느리게 실행되는 것 같습니다.

Miopas 에 2017년 06월 23일

😄3 👍1

tensorflow를 1.0.0(tensorflow-GPU)으로 다운그레이드했으며 저에게 효과적이라는 사실을 모든 사람에게 업데이트하고 싶습니다. 모델이 예상대로 작동하고 있습니다. 1.0.0의 CPU 버전이 예상대로 작동해야 한다고 가정합니까? 또는?.
감사 해요 :)

PratsBhatt 에 2017년 06월 23일

안녕하세요 여러분, 여전히 관심이 있는지는 모르겠지만 embedding_attention_seq2seq 함수에 매개변수로 전달된 셀을 복사하는 작업과 관련된 문제라는 것을 알았습니다. 인코더와 디코더 모두에 동일한 셀 정의가 사용되기 때문입니다. 이 튜토리얼은 동적 seq2seq와 대조적으로 버킷팅이 있는 seq2seq 모델을 사용하기 때문에 더 이상 사용되지 않는다고 생각합니다. 그러나 작동하는 수정된 기능을 붙여넣고 있습니다. 함수는 tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py 파일에서 업데이트됩니다.

감사,
파비오

```!파이썬
def embedding_attention_seq2seq(encoder_inputs,
디코더_입력,
enc_cell,
dec_cell,
num_encoder_symbols,
num_decoder_symbols,
임베딩_크기,
num_heads=1,
output_projection=없음,
feed_previous=거짓,
dtype=없음,
범위=없음,
initial_state_attention=거짓):
"""주의를 기울여 sequence-to-sequence 모델을 포함합니다.

이 모델은 먼저 새로 생성된 임베딩(모양
[num_encoder_symbols x input_size]). 그런 다음 RNN을 실행하여 인코딩합니다.
임베디드 인코더_입력을 상태 벡터에 넣습니다. 이 출력을 유지합니다.
나중에 주의를 끌기 위해 모든 단계에서 RNN을 사용합니다. 다음으로 디코더_입력을 포함합니다.
새로 생성된 다른 임베딩(모양 [num_decoder_symbols x
input_size]). 그런 다음 마지막으로 초기화된 주의 디코더를 실행합니다.
인코더 상태, 임베디드 디코더_입력 및 인코더 출력에 주의.

경고: output_projection이 None이면 주의 벡터의 크기
변수는 num_decoder_symbols에 비례하여 만들어지며 클 수 있습니다.

인수:
인코더_입력: [batch_size] 모양의 1D int32 텐서 목록입니다.
디코더_입력: 모양이 [batch_size]인 1D int32 텐서의 목록입니다.
cell: tf.nn.rnn_cell.RNNCell 셀 기능 및 크기를 정의합니다.
num_encoder_symbols: 정수; 인코더 측의 기호 수.
num_decoder_symbols: 정수; 디코더 측의 심볼 수.
Embedding_size: 정수, 각 심볼에 대한 임베딩 벡터의 길이.
num_heads: Attention_states에서 읽은 주의 헤드의 수입니다.
output_projection: 없음 또는 출력 투영 가중치 쌍(W, B) 및
편견; W의 모양은 [output_size x num_decoder_symbols]이고 B는
모양 [num_decoder_symbols]; 제공되고 feed_previous=True인 경우 각각
공급된 이전 출력은 먼저 W를 곱하고 B를 더합니다.
feed_previous: 부울 또는 스칼라 부울 텐서 참이면 첫 번째
Decoder_inputs("GO" 기호)가 사용되고 다른 모든 디코더
입력은 이전 출력에서 가져옵니다(embedding_rnn_decoder에서와 같이).
False인 경우 Decoder_inputs는 주어진 대로 사용됩니다(표준 디코더 경우).
dtype: 초기 RNN 상태의 dtype(기본값: tf.float32).
범위: 생성된 하위 그래프에 대한 VariableScope; 기본값은
"embedding_attention_seq2seq".
initial_state_attention: False(기본값)인 경우 초기 주의는 0입니다.
True이면 초기 상태에서 주의 초기화 및 주의
상태.

보고:
(출력, 상태) 형식의 튜플, 여기서:
output: 2D Tensor의 Decoder_inputs와 동일한 길이의 목록
생성된 모양을 포함하는 [batch_size x num_decoder_symbols]
출력.
state: 최종 시간 단계에서 각 디코더 셀의 상태.
[batch_size x cell.state_size] 모양의 2D Tensor입니다.
""
variable_scope.variable_scope(
범위 또는 "embedding_attention_seq2seq", dtype=dtype) 범위로:
dtype = 범위.dtype
# 인코더.

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 에 2017년 06월 25일

👍14 ❤4

@fabiofumarola 기능 주셔서 감사합니다. 정말 도움이 될 것 같습니다. 나는 또한 튜토리얼이 더 이상 사용되지 않는 것을 보았습니다. 나는 여전히 공식 튜토리얼 릴리스를 기다리고 있습니다. 새로운 API를 사용한 것 같습니다. 새 API에서 코딩을 시작하기 위해 조회할 수 있는 코드가 있습니까?
도움을 주시면 감사하겠습니다. 다시 한번 감사드립니다 :)

PratsBhatt 에 2017년 06월 26일

@syw2014 문제를 해결하셨나요?

w268wang 에 2017년 06월 26일

@w268wang 은 아직 다른 솔루션을 기다리고 있지만 @Miopas의 의견은 시도해 볼 수 있으며 @fabiofumarola 의 솔루션을 시도하고 있습니다.

syw2014 에 2017년 06월 27일

TypeError: embedding_attention_seq2seq() missing 1 required positional argument: 'dec_cell' 라고 적혀있습니다.
@fabiofumarola 가 게시한 업데이트를 사용한 후. 도와주시겠어요?

sachinh35 에 2017년 07월 02일

예, 내가 제안한 업데이트를 변경해야 하기 때문에
embedding_attention_seq2seq 함수. 자신의 소스 파일로 이동하면
tensorflow 릴리스에서는 스스로 메서드 정의를 변경할 수 있습니다.

2017년 7월 2일 일요일 18:15, sachinh35 [email protected] trote

TypeError:embding_attention_seq2seq() 누락 1이 필요하다고 표시됩니다.
위치 인수: 'dec_cell'
—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312500996 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/ABepUEc3W8m5CVDQGnCLu4dcJVFwwLDZks5sJ8IOgaJpZM4MWl4f
.
>

Gmail 모바일에서 전송됨

fabiofumarola 에 2017년 07월 02일

예, 나는 같은 일을했습니다. tensorflow 릴리스에서 seq2seq.py 파일의 기능을 변경했습니다. 여전히 동일한 오류가 발생합니다. 함수에 대한 인수가 하나 더 있습니까?

sachinh35 에 2017년 07월 02일

예, 이제 코드에서 rnn_cells에 지정해야 합니다. 인코더용
디코더에 대한 또 다른.

2017년 7월 2일 일요일 20:54 fabio fumarola [email protected] 이 다음과 같이 썼습니다.

네
2017년 7월 2일 일요일 18:50에 sachinh35 [email protected] 에서 다음과 같이 썼습니다.
예, 나는 같은 일을했습니다. seq2seq.py 파일의 기능을 변경했습니다.
텐서플로 릴리스. 여전히 동일한 오류가 발생합니다. 하나 있나요
기능에 대한 더 많은 인수?
—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312503106 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/ABepUOXTQC_mzLuhcwW0iZRVkLmmr8yIks5sJ8pugaJpZM4MWl4f
.
>
Gmail 모바일에서 전송됨

fabiofumarola 에 2017년 07월 02일

나는 이것에 완전히 새로운 것입니다. 이것은 아주 기본적인 질문일 수 있지만 이 코드에서 디코더 셀로 전달할 인수를 말할 수 있습니까? 자체 데이터 세트를 사용하여 tensorflow 자습서에 표시된 대로 seq2seq를 개발하려고 합니다.

`
__future__에서 import absolute_import
__future__ 수입 부문에서
__future__에서 print_function 가져오기

무작위로 가져오기

numpy를 np로 가져오기
from Six.moves import xrange # pylint: disable=redefined-builtin
텐서플로를 tf로 가져오기

import data_utils

클래스 Seq2SeqModel(객체):
def __init__(자신,
소스_어휘_크기,
target_vocab_size,
양동이,
크기,
num_layers,
max_gradient_norm,
배치 크기,
학습 속도,
learning_rate_decay_factor,
use_lstm=거짓,
num_samples=512,
forward_only=거짓,
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 단계(자체, 세션, 인코더_입력, 디코더_입력, 대상_가중치,
버킷 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(자신, 데이터, 버킷 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 에 2017년 07월 03일

이것은 스택 오버플로에 대한 좋은 질문입니다.

2017년 7월 3일 오전 8시 46분에 "sachinh35" [email protected] 이 작성했습니다.

나는 이것에 완전히 새로운 것입니다. 어쩌면 이것은 아주 기본적인 질문일 수도 있지만
이 코드에서 디코더 셀로 전달할 인수를 알려주세요. 그래요
자신을 사용하여 tensorflow 자습서에 표시된 대로 seq2seq를 개발하려고 시도합니다.
데이터 세트.
`# Copyright 2015 TensorFlow 작성자. 판권 소유.
Apache 라이선스 버전 2.0("라이선스")에 따라 라이선스가 부여됩니다. 당신은 할 수있다
라이선스를 준수하지 않는 한 이 파일을 사용하지 마십시오. 당신은 얻을 수 있습니다
http://www.apache.org/licenses/LICENSE-2.0 에 있는 라이선스 사본
관련 법률에서 요구하거나 서면으로 동의한 소프트웨어 배포
라이센스에 따라 보증 없이 "있는 그대로" 배포됩니다.
또는 명시적이든 묵시적이든 모든 종류의 조건. 라이선스 참조
아래의 권한 및 제한 사항을 관리하는 특정 언어
특허. ==================================================== ===========
"""주의 메커니즘이 있는 시퀀스 대 시퀀스 모델입니다."""
향후 가져오기 absolute_import에서
미래 수입 부서에서
향후 가져오기에서 print_function
무작위로 가져오기
numpy를 np로 가져오기
from Six.moves import xrange # pylint: disable=redefined-builtin
텐서플로를 tf로 가져오기
import data_utils
클래스 Seq2SeqModel(객체):
"""주의가 있고 여러 버킷에 대한 시퀀스 대 시퀀스 모델입니다.
이 클래스는 인코더로 다층 순환 신경망을 구현합니다.
및 주의 기반 디코더. 에 설명된 모델과 동일합니다.
이 문서: http://arxiv.org/abs/1412.7449 - 거기에서 찾아보십시오.
세부,
또는 완전한 모델 구현을 위해 seq2seq 라이브러리에 넣습니다.
이 클래스를 사용하면 LSTM 셀 외에 GRU 셀도 사용할 수 있습니다.
큰 출력 어휘 크기를 처리하기 위해 샘플링된 softmax. 단층
이 모델의 버전이지만 양방향 인코더가 있는
http://arxiv.org/abs/1409.0473
샘플링된 softmax는 다음 문서의 섹션 3에 설명되어 있습니다.
http://arxiv.org/abs/1412.2007
""
def 초기화 (자신,
소스_어휘_크기,
target_vocab_size,
양동이,
크기,
num_layers,
max_gradient_norm,
배치 크기,
학습 속도,
learning_rate_decay_factor,
use_lstm=거짓,
num_samples=512,
forward_only=거짓,
dtype=tf.float32):
"""모델을 만듭니다.
인수:
source_vocab_size: 소스 어휘의 크기.
target_vocab_size: 대상 어휘의 크기.
버킷: 쌍(I, O)의 목록, 여기서 I은 최대 입력 길이를 지정합니다.
해당 버킷에서 처리되고 O는 최대 출력을 지정합니다.
길이. I 또는 출력보다 입력이 긴 훈련 인스턴스
O보다 길면 다음 버킷으로 푸시되고 그에 따라 채워집니다.
목록이 정렬되어 있다고 가정합니다(예: [(2, 4), (8, 16)].
크기: 모델의 각 레이어에 있는 단위 수입니다.
num_layers: 모델의 레이어 수.
max_gradient_norm: 그라디언트가 최대로 이 표준으로 잘립니다.
batch_size: 훈련 중에 사용된 배치의 크기.
모델 구성은 batch_size와 무관하므로
예를 들어 디코딩을 위해 이것이 편리한 경우 초기화 후에 변경됩니다.
learning_rate: 시작할 학습률입니다.
learning_rate_decay_factor: 필요할 때 이만큼 학습률을 감소시킵니다.
use_lstm: true이면 GRU 셀 대신 LSTM 셀을 사용합니다.
num_samples: 샘플링된 softmax의 샘플 수입니다.
forward_only: 설정된 경우 모델에서 역방향 패스를 구성하지 않습니다.
dtype: 내부 변수를 저장하는 데 사용할 데이터 유형입니다.
""
self.source_vocab_size = source_vocab_size
self.target_vocab_size = target_vocab_size
self.buckets = 버킷
self.batch_size = 배치_크기
self.learning_rate = tf.Variable(
float(learning_rate), 훈련 가능=거짓, dtype=dtype)
self.learning_rate_decay_op = self.learning_rate.assign(
self.learning_rate * learning_rate_decay_factor)
self.global_step = tf.Variable(0, 훈련 가능=거짓)
샘플링된 softmax를 사용하는 경우 출력 투영이 필요합니다.
output_projection = 없음
softmax_loss_function = 없음
샘플링된 소프트맥스는 어휘 크기보다 적은 샘플링을 하는 경우에만 의미가 있습니다.
num_samples > 0 및 num_samples < self.target_vocab_size:
w_t = tf.get_variable("proj_w", [self.target_vocab_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(레이블, 입력):
레이블 = tf.reshape(레이블, [-1, 1])
# 32비트 부동 소수점을 사용하여 sampled_softmax_loss를 계산해야 합니다.
# 수치적 불안정성을 피하십시오.
local_w_t = tf.cast(w_t, tf.float32)
local_b = tf.cast(b, tf.float32)
local_inputs = tf.cast(입력, tf.float32)
반환 tf.cast(
tf.nn.sampled_softmax_loss(local_w_t, local_b, local_inputs, 레이블,
num_samples, self.target_vocab_size),
dtype)
softmax_loss_function = 샘플링된 손실
RNN을 위한 내부 다층 셀을 만듭니다.
def single_cell():
반환 tf.nn.rnn_cell.GRUCell(크기)
use_lstm인 경우:
def single_cell():
반환 tf.nn.rnn_cell.BasicLSTMCell(크기)
셀 = single_cell()
num_layers > 1인 경우:
cell = tf.nn.rnn_cell.MultiRNNCell([single_cell() for _ in range(num_layers)])
seq2seq 함수: 입력과 주의를 위해 임베딩을 사용합니다.
def seq2seq_f(encoder_inputs, 디코더_입력, do_decode):
반환 tf.contrib.legacy_seq2seq.embedding_attention_seq2seq(
인코더_입력,
디코더_입력,
셀,
num_encoder_symbols=source_vocab_size,
num_decoder_symbols=target_vocab_size,
embedding_size=크기,
output_projection=출력_투영,
feed_previous=do_decode,
dtype=dtype)
입력에 대한 피드.
self.encoder_inputs = []
self.decoder_inputs = []
self.target_weights = []
for i in xrange(buckets[-1][0]): # 마지막 버킷이 가장 큰 버킷입니다.
self.encoder_inputs.append(tf.placeholder(tf.int32, 모양=[없음],
이름="인코더{0}".format(i)))
xrange(buckets[-1][1] + 1)의 i에 대해:
self.decoder_inputs.append(tf.placeholder(tf.int32, 모양=[없음],
이름="디코더{0}".format(i)))
self.target_weights.append(tf.placeholder(dtype, shape=[없음],
이름="무게{0}".형식(i)))
우리의 목표는 1만큼 이동된 디코더 입력입니다.
대상 = [self.decoder_inputs[i + 1]
for i in xrange(len(self.decoder_inputs) - 1)]
훈련 결과 및 손실.
forward_only인 경우:
self.outputs, self.losses = tf.contrib.legacy_seq2seq.model_with_buckets(
self.encoder_inputs, self.decoder_inputs, 대상,
self.target_weights, 버킷, 람다 x, y: seq2seq_f(x, y, True),
softmax_loss_function=softmax_loss_function)
# 출력 투영을 사용하는 경우 디코딩을 위해 출력을 투영해야 합니다.
output_projection이 None이 아닌 경우:
xrange(len(buckets))의 b에 대해:
self.outputs[b] = [
tf.matmul(출력, output_projection[0]) + output_projection[1]
self.outputs[b]의 출력용
]
또 다른:
self.outputs, self.losses = tf.contrib.legacy_seq2seq.model_with_buckets(
self.encoder_inputs, self.decoder_inputs, 대상,
self.target_weights, 버킷,
람다 x, y: seq2seq_f(x, y, False),
softmax_loss_function=softmax_loss_function)
모델 훈련을 위한 그라디언트 및 SGD 업데이트 작업.
매개변수 = tf.trainable_variables()
forward_only가 아닌 경우:
self.gradient_norms = []
self.updates = []
opt = tf.train.GradientDescentOptimizer(self.learning_rate)
xrange(len(buckets))의 b에 대해:
그라디언트 = tf.gradients(self.losses[b], params)
clipped_gradients, norm = tf.clip_by_global_norm(그라디언트,
max_gradient_norm)
self.gradient_norms.append(표준)
self.updates.append(opt.apply_gradients(
zip(clipping_gradients, params), global_step=self.global_step))
self.saver = tf.train.Saver(tf.global_variables())
def 단계(자체, 세션, 인코더_입력, 디코더_입력, 대상_가중치,
버킷 ID, forward_only):
"""주어진 입력을 공급하는 모델의 단계를 실행합니다.
인수:
session: 사용할 tensorflow 세션입니다.
인코더_입력: 인코더 입력으로 공급할 numpy int 벡터 목록입니다.
디코더_입력: 디코더 입력으로 공급할 numpy int 벡터 목록입니다.
target_weights: 대상 가중치로 제공할 numpy float 벡터 목록입니다.
bucket_id: 사용할 모델의 버킷입니다.
forward_only: 뒤로 단계를 수행할지 아니면 앞으로만 수행할지 여부.
보고:
그래디언트 놈으로 구성된 트리플(또는 뒤로 하지 않았다면 None),
평균 당혹도 및 출력.
레이즈:
ValueError: 인코더_입력, 디코더_입력 또는
target_weights가 지정된 bucket_id의 버킷 크기와 일치하지 않습니다.
""
크기가 일치하는지 확인하십시오.
인코더_크기, 디코더_크기 = self.buckets[bucket_id]
len(encoder_inputs) != 인코더_크기인 경우:
raise ValueError("인코더 길이는 버킷의 길이와 같아야 합니다."
" %d != %d." % (len(encoder_inputs), 인코더_크기))
len(decoder_inputs) != 디코더 크기인 경우:
raise ValueError("디코더 길이는 버킷의 길이와 같아야 합니다."
" %d != %d." % (len(decoder_inputs), 디코더_크기))
len(target_weights) != 디코더 크기:
raise ValueError("무게 길이는 버킷의 길이와 같아야 합니다."
" %d != %d." % (len(target_weights), 디코더_크기))
입력 피드: 인코더 입력, 디코더 입력, 제공되는 target_weights.
input_feed = {}
xrange(encoder_size)의 l:
input_feed[self.encoder_inputs[l].name] = 인코더_입력[l]
xrange(decoder_size)의 l:
input_feed[self.decoder_inputs[l].name] = 디코더_입력[l]
input_feed[self.target_weights[l].name] = target_weights[l]
우리의 목표는 1만큼 이동된 디코더 입력이므로 하나 더 필요합니다.
last_target = self.decoder_inputs[decoder_size].name
input_feed[last_target] = np.zeros([self.batch_size], dtype=np.int32)
출력 피드: 후진 단계를 수행하는지 여부에 따라 다릅니다.
forward_only가 아닌 경우:
output_feed = [self.updates[bucket_id], # SGD를 수행하는 업데이트 작업.
self.gradient_norms[bucket_id], # 기울기 노름.
self.losses[bucket_id]] # 이 배치의 손실입니다.
또 다른:
output_feed = [self.losses[bucket_id]] # 이 배치의 손실입니다.
for l in xrange(decoder_size): # 출력 로그.
output_feed.append(self.outputs[bucket_id][l])
출력 = session.run(출력_피드, 입력_피드)
forward_only가 아닌 경우:
return output[1], output[2], None # 기울기 노름, 손실, 출력 없음.
또 다른:
return None, output[0], output[1:] # 기울기 노름, 손실, 출력이 없습니다.
def get_batch(자신, 데이터, 버킷 ID):
"""지정된 버킷에서 데이터의 무작위 배치를 가져오고 단계를 준비하십시오.
단계(..)에서 데이터를 공급하려면 일괄 처리 중심 벡터 목록이어야 하지만
여기에 있는 데이터는 단일 길이 주요 사례를 포함합니다. 그래서 이것의 주요 논리는
기능은 데이터 케이스를 피드에 적합한 형식으로 다시 인덱싱하는 것입니다.
인수:
data: 각 요소가 포함하는 len(self.buckets) 크기의 튜플
배치를 생성하는 데 사용하는 입력 및 출력 데이터 쌍의 목록입니다.
bucket_id: 배치를 가져올 버킷의 정수입니다.
보고:
트리플(encoder_inputs, decoder_inputs, target_weights)
나중에 step(...)을 호출하기에 적절한 형식을 가진 구성된 배치입니다.
""
인코더_크기, 디코더_크기 = self.buckets[bucket_id]
인코더_입력, 디코더_입력 = [], []
데이터에서 인코더 및 디코더 입력의 무작위 배치를 가져옵니다.
필요한 경우 패드를 채우고 인코더 입력을 역전시키고 디코더에 GO를 추가합니다.
xrange(self.batch_size)의 _에 대해:
인코더_입력, 디코더_입력 = random.choice(데이터[버킷_ID])
# 인코더 입력은 패딩된 다음 반전됩니다.
인코더_패드 = [data_utils.PAD_ID] * (encoder_size - len(encoder_input))
encoder_inputs.append(list(reversed(encoder_input + encoder_pad)))
# 디코더 입력은 추가 "GO" 기호를 얻고 패딩됩니다.
디코더_패드_크기 = 디코더_크기 - len(decoder_input) - 1
Decoder_inputs.append([data_utils.GO_ID] + 디코더_입력 +
[data_utils.PAD_ID] * 디코더_패드_크기)
이제 위에서 선택한 데이터에서 배치 주요 벡터를 생성합니다.
batch_encoder_inputs, batch_decoder_inputs, batch_weights = [], [], []
배치 인코더 입력은 다시 인덱싱된 인코더_입력입니다.
xrange(encoder_size)의 length_idx:
batch_encoder_inputs.append(
np.array([인코더_입력[배치_idx][길이_idx]
xrange(self.batch_size)]의 batch_idx용], dtype=np.int32))
배치 디코더 입력은 다시 인덱싱된 디코더_입력이며 가중치를 생성합니다.
xrange(decoder_size)의 length_idx:
batch_decoder_inputs.append(
np.array([디코더_입력[배치_idx][길이_idx]
xrange(self.batch_size)]의 batch_idx용], dtype=np.int32))
# 패딩 대상에 대해 target_weights를 0으로 만듭니다.
batch_weight = np.ones(self.batch_size, dtype=np.float32)
xrange(self.batch_size)의 batch_idx:
# 해당 target이 PAD symbol이면 weight를 0으로 설정한다.
# 해당 대상은 1 앞으로 이동한 디코더_입력입니다.
length_idx < 디코더 크기 - 1인 경우:
대상 = 디코더_입력[배치_idx][길이_idx + 1]
length_idx == 디코더_크기 - 1 또는 대상 == data_utils.PAD_ID인 경우:
배치 무게[배치_idx] = 0.0
batch_weights.append(batch_weight)
반환 batch_encoder_inputs, batch_decoder_inputs, batch_weights`
—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312679587 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/ABtim0l5UMHHtbL1sz7meXserV8NVS7cks5sKQzXgaJpZM4MWl4f
.

ebrevdo 에 2017년 07월 03일

👍1

괜찮아! 그래도 고마워! :)

sachinh35 에 2017년 07월 03일

@ebrevdo 새 API를 사용하는 seq2seq의 새 튜토리얼이 언제 나올지에 대한 업데이트가 있습니까?
감사합니다. 놀라운 작품!.

PratsBhatt 에 2017년 07월 03일

👍1

예, 새로운 튜토리얼을 기다리고 있습니다... 조만간 출시될 예정인지 알고 싶습니다.. @ebrevdo

커널 테스트에서 코드를 가져오고 기존 seq2seq로 빔 검색을 개조하려고 시도했지만 도전적이었습니다...

prashantserai 에 2017년 07월 03일

이번주가 기다려집니다!

2017년 7월 3일 오전 10시 16분에 "prashantserai" [email protected] 이 작성했습니다.

네, 새로운 튜토리얼을 기다리고 있습니다...
조만간 출시 예정.. @ebrevdo
https://github.com/ebrevdo
커널 테스트에서 코드를 가져오고 다음으로 빔 검색을 개조하려고 했습니다.
레거시 seq2seq이지만 도전적인 것처럼 보였습니다 ...
—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312697274 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/ABtim45-HTuQrIRDhphqqHjqkKOKTe53ks5sKSHYgaJpZM4MWl4f
.

ebrevdo 에 2017년 07월 03일

👍5 ❤1

안녕하세요 여러분,

이 문제에 대한 업데이트는 Mac os x용 tensorflow 1.1-gpu에서도 동일하게 발생합니다.

tshi1983 에 2017년 07월 20일

@tshi1983
우분투용 tensorflow 1.1-gpu에서도 동일한 문제가 발생했습니다.
tf 1.2로 업그레이드합니다. 여전히 작동하지 않습니다.
그런 다음 파일에서 embedding_attention_seq2seq 함수를 변경합니다.
tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py
위에서 제안한 @fabiofumarola 로.
이제 훈련을 시작합니다. 아직 디코딩을 테스트하지 않았습니다.

selinachenxi 에 2017년 07월 24일

셀 정의의 코드를 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(
      ...
      )

그런 다음 "python translate.py --data_dir data/ --train_dir checkpoint/ --size=256 --num_layers=2 --steps_per_checkpoint=50"이 작동할 수 있습니다.

huxuanlai 에 2017년 07월 31일

👍12 🎉1

@huxuanlai 작동합니다! 적어도 지금은 훈련 중이야, thx!

a111xushuai 에 2017년 07월 31일

@huxuanlai 저에게도 효과적입니다.

nathan-standafer 에 2017년 08월 05일

동일한 AttributeError: 'NoneType' object has no attribute 'update' 를 받고 있지만 tf.contrib.legacy_seq2seq.model_with_buckets 입니다. 우분투 16.04 lts에서 tf 1.2.1(GPU)을 실행 중입니다.

이것은 버킷이 1개 이상인 경우에만 발생하는 것 같습니다.

전체 역추적:

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 에 2017년 08월 10일

@Tshzzz @jtubert
thx, 귀하의 솔루션이 저에게 효과적이었습니다. 내 tf 버전은 1.1.0입니다.

나는 다음에서 변경했다:

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

에게:

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

LevineHuang 에 2017년 08월 16일

❤2 👍2

이것은 여전히 고정되지 않았으며 가능한 모든 솔루션을 시도했지만 이 스레드와 stackoverflow에서 언급한 솔루션은 tensorflow 1.3 또는 1.2 또는 1.1에서 작동하지 않습니다.

saurabhvyas 에 2017년 08월 18일

이 오류가 발생했습니다.
TypeError: embedding_attention_seq2seq() missing 1 required positional argument: 'dec_cell'

오류는 seq2seq_model.py의 142행인 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)

이 오류가 발생하여 문제를 해결한 사람은 이 문제를 해결하도록 도와주세요.

comsian106 에 2017년 08월 18일

👍1

ValueError: RNNCell 재사용 시도첫 번째 사용과 다른 변수 범위를 사용합니다. 셀의 첫 번째 사용은 범위 'rnn/multi_rnn_cell/cell_0/gru_cell'이었고, 이 시도는 범위 'rnn/multi_rnn_cell/cell_1/gru_cell'입니다. 다른 가중치 세트를 사용하려면 셀의 새 인스턴스를 만드십시오. 이전에 MultiRNNCell([GRUCell(...)] * num_layers)을 사용했다면 MultiRNNCell([GRUCell(...) for _ in range(num_layers)])로 변경합니다. 양방향 RNN의 순방향 및 역방향 셀 모두와 동일한 셀 인스턴스를 사용하기 전에 두 개의 인스턴스를 생성하기만 하면 됩니다(하나는 정방향, 하나는 역방향). 2017년 5월에 scope=None(자동 모델 저하로 이어질 수 있으므로 이 오류는 그때까지 유지됨)으로 호출될 때 기존에 저장된 가중치를 사용하도록 이 셀의 동작을 전환하기 시작할 것입니다.

원산지 코드:
tensorflow.contrib에서 가져오기 rnn
입력 = tf.placeholder(dtype=tf.int32, 모양=[없음, 없음], 이름="입력")
keep_prob = tf.placeholder(dtype=tf.float32, name="keep_prob")
셀 = rnn.GRUCell(10)
cell = rnn.DropoutWrapper(cell=cell, input_keep_prob=keep_prob)
cell = rnn.MultiRNNCell([범위(5)에 있는 _에 대한 셀], state_is_tuple=True)

출력, 상태 = tf.nn.dynamic_rnn(셀=셀, 입력=look_up, dtype=tf.float32)
해결책:
입력 = tf.placeholder(dtype=tf.int32, 모양=[없음, 없음], 이름="입력")
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 에 2017년 08월 25일

👍3

tf nightlies에 이 문제가 있습니까?

2017년 10월 1일 오전 8시 34분에 "Baohua Zhou" 알림 @github.com이 작성했습니다.

ios와 함께 CPU에서 tensorflow 1.1을 사용할 때도 동일한 문제가 있습니다.
—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-333384725 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/ABtimwOv7vf5vvFXBllbZryjCFwmJcU6ks5sn7DxgaJpZM4MWl4f
.

ebrevdo 에 2017년 10월 01일

AttributeError: 'NoneType' 개체에 '업데이트' 속성이 없습니다.

tf=1.3에서

PR-Iyyer 에 2017년 10월 23일

ValueError: RNNCell 재사용 시도첫 번째 사용과 다른 변수 범위를 사용합니다. cell의 첫 번째 사용은 범위 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_0/gru_cell'이었고, 이 시도는 범위 'embedding_attention_seq2seq/rnn/multi_rnn_cell/cell_1/gru_cell'입니다. 다른 가중치 세트를 사용하려면 셀의 새 인스턴스를 만드십시오. 이전에 MultiRNNCell([GRUCell(...)] * num_layers)을 사용했다면 MultiRNNCell([GRUCell(...) for _ in range(num_layers)])로 변경합니다. 양방향 RNN의 순방향 및 역방향 셀 모두와 동일한 셀 인스턴스를 사용하기 전에 두 개의 인스턴스를 생성하기만 하면 됩니다(하나는 정방향, 하나는 역방향). 2017년 5월에 scope=None(자동 모델 저하로 이어질 수 있으므로 이 오류는 그때까지 유지됨)으로 호출될 때 기존에 저장된 가중치를 사용하도록 이 셀의 동작을 전환하기 시작할 것입니다.

rashmishrm 에 2017년 11월 27일

14일 동안 활동이 없었으며 awaiting tensorflower 레이블이 지정되었습니다. 그에 따라 레이블 및/또는 상태를 업데이트하십시오.

tensorflowbutler 에 2017년 12월 22일

TensorFlower를 기다리는 잔소리: 14일 동안 활동이 없었으며 awaiting tensorflower 레이블이 할당되었습니다. 그에 따라 레이블 및/또는 상태를 업데이트하십시오.

tensorflowbutler 에 2018년 01월 05일

해결책은 최신 버전의 TF로 이동하는 것입니다. 이 스레드는 원래 문제에서 크게 벗어났습니다. 폐쇄.

ebrevdo 에 2018년 01월 05일

즉각적인 솔루션을 원한다면 내가 시도한 것을 시도 할 수 있습니다.

pip install tensorflow==1.0
문제는 tenorflow 1.1 버전에 있습니다. 저에게 효과적이었습니다.

monk1337 에 2018년 04월 13일

Tensorflow: ValueError: 처음 사용한 것과 다른 변수 범위로 RNNCell을 재사용하려고 했습니다.

가장 유용한 댓글

모든 102 댓글

모델(README.md의 FAQ 참조)

입력

NLAYERS=3개의 GRU 셀 레이어를 사용하여 전개된 SEQLEN=30회# dynamic_rnn은 입력 Xo의 크기에서 SEQLEN을 추론합니다.

>

>

특허. ==================================================== ===========

샘플링된 softmax를 사용하는 경우 출력 투영이 필요합니다.

샘플링된 소프트맥스는 어휘 크기보다 적은 샘플링을 하는 경우에만 의미가 있습니다.

RNN을 위한 내부 다층 셀을 만듭니다.

seq2seq 함수: 입력과 주의를 위해 임베딩을 사용합니다.

입력에 대한 피드.

우리의 목표는 1만큼 이동된 디코더 입력입니다.

훈련 결과 및 손실.

모델 훈련을 위한 그라디언트 및 SGD 업데이트 작업.

크기가 일치하는지 확인하십시오.

입력 피드: 인코더 입력, 디코더 입력, 제공되는 target_weights.

우리의 목표는 1만큼 이동된 디코더 입력이므로 하나 더 필요합니다.

출력 피드: 후진 단계를 수행하는지 여부에 따라 다릅니다.

데이터에서 인코더 및 디코더 입력의 무작위 배치를 가져옵니다.

필요한 경우 패드를 채우고 인코더 입력을 역전시키고 디코더에 GO를 추가합니다.

이제 위에서 선택한 데이터에서 배치 주요 벡터를 생성합니다.

배치 인코더 입력은 다시 인덱싱된 인코더_입력입니다.

배치 디코더 입력은 다시 인덱싱된 디코더_입력이며 가중치를 생성합니다.

관련 문제