अनुवाद उदाहरण को चलाने का प्रयास करते समय मुझे वही त्रुटि मिल रही है (यहां तक ​​​​कि छोटा आत्म परीक्षण करते समय भी) जो यहां पाया जा सकता है: https://github.com/tensorflow/models/tree/master/tutorials/rnn/translate

मैं एक ही मुद्दे से मिला। यदि आप सभी मास्टर शाखा पर संकलित संस्करण का उपयोग कर रहे हैं, तो मेरा मानना ​​​​है कि हम हाल की प्रतिबद्धता के कारण एक ही समस्या हैं। जैसा कि प्रतिबद्ध संदेश कहता है:

tf.contrib.rnn में सभी RNNC कोशिकाओं को tf.layers Layers की तरह कार्य करें, लेकिन बिना किसी के लिए कठोर शब्दार्थ के साथ
डब्ल्यू:

1. __call__ के पहले प्रयोग पर, प्रयुक्त स्कोप सेल में स्टोर हो जाता है। आरएनएनसेल उस दायरे में वजन बनाने की कोशिश करता है लेकिन अगर कुछ पहले से ही सेट हैं, तो एक त्रुटि उठाई जाती है जब तक कि आरएनएनसेल का निर्माण तर्क पुन: उपयोग = ट्रू के साथ नहीं किया गया था।

2. उसी सेल इंस्टेंस के __call__ का बाद में उपयोग उसी दायरे में होना चाहिए।
   यदि ऐसा नहीं है, तो एक त्रुटि उठाई जाती है।

मेरे मामले से, जो पीटीबी ट्यूटोरियल चला रहा है, समाधान केवल reuse के साथ नामित पैरामीटर को लाइन 112 पर जोड़ने के लिए है:

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

तब यह काम करता है।

@ebrevdo क्या आप कृपया इसे देख सकते हैं?

शेक्सपियर आरएनएन रेपो पर विंडोज/जीपीयू बिल्ड 105 का उपयोग करते समय यह समस्या मेरे लिए दोहराई जाती है।

विन 1.0.0/जीपीयू रिलीज के साथ कोड चलाते समय, कोई समस्या नहीं है।

ऐसा लगता है कि रेपो टीएफ 1.0 पर लक्षित है, इंटरमीडिएट रिलीज नहीं।

8 मार्च, 2017 को अपराह्न 3:56 बजे, "टॉम वानज़ेक" नोटिफिकेशन @github.com ने लिखा:

शेक्सपियर पर विंडोज़/जीपीयू बिल्ड 105 का उपयोग करते समय यह समस्या मेरे लिए दोहराई जाती है
आरएनएन रेपो https://github.com/martin-gorner/tensorflow-rnn-shakespeare ।

विन 1.0.0/जीपीयू रिलीज के साथ कोड चलाते समय, कोई समस्या नहीं है।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285209555 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/ABtim5ansaL1KN51T4nCaqLnqw2QHN4Wks5rj0BBgaJpZM4MWl4f
.

@tongda , मैं CPU मोड में MacOS पर काम करते हुए Tensorflow 1.0 के रिलीज़ संस्करण का उपयोग कर रहा हूँ। मैं यह देखने के लिए मास्टर शाखा में स्विच करूंगा कि क्या यह "पुन: उपयोग" पैरामीटर जोड़कर काम करता है, धन्यवाद।

doncat99: यदि आप ऐसा करते हैं, तो कृपया सुनिश्चित करें कि आपका कोड टेंसरफ़्लो संस्करण से पूछताछ करता है
और यदि संस्करण मास्टर शाखा संस्करण से कम है तो ध्वज उठाता है।
आपको इसके खिलाफ जांच करने की आवश्यकता हो सकती है:

tensorflow.core आयात संस्करणों से
संस्करण.GIT_VERSION

बुधवार, 8 मार्च, 2017 को शाम 6:58 बजे, doncat99 सूचनाएं @github.com ने लिखा:

@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 तो मध्यवर्ती स्थिर रिलीज के साथ काम करने की अनुमति देने के लिए शेक्सपियर आरएनएन में सुझाए गए परिवर्तन क्या होंगे?

यहाँ कोड का प्रमुख वास्तु खंड है, जो अब बिल्ड # 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 ध्वज के संबंध में कोई दस्तावेज नहीं मिल रहा है?

अग्रिम में धन्यवाद।

उपयोग:

मल्टीसेल = rnn.MultiRNNCell([rnn.DropoutWrapper(rnn.GRUCell(INTERNALSIZE),
input_keep_prob=pkeep) _ के लिए रेंज में(NLAYERS)], State_is_tuple=False)

जो हर लेयर के लिए एक अलग ग्रेसेल ऑब्जेक्ट बनाता है।

10 मार्च, 2017 को सुबह 7:44 बजे, "टॉम वानज़ेक" नोटिफिकेशन @github.com ने लिखा:

@ebrevdo https://github.com/ebrevdo तो क्या सुझाव दिया जाएगा
मध्यवर्ती के साथ काम करने की अनुमति देने के लिए शेक्सपियर आरएनएन में परिवर्तन
स्थिर निस्तार?

यहाँ कोड का प्रमुख वास्तु खंड है, जो अब विफल हो जाता है
बिल्ड#105:

मॉडल (README.md में अक्सर पूछे जाने वाले प्रश्न देखें)

lr = tf.प्लेसहोल्डर (tf.float32, नाम = 'lr') # सीखने की दर
pkeep = tf.placeholder(tf.float32, name='pkeep') # ड्रॉपआउट पैरामीटर
बैचसाइज = tf.प्लेसहोल्डर (tf.int32, नाम = 'बैचसाइज')

आदानों

X = tf.प्लेसहोल्डर (tf.uint8, [कोई नहीं, कोई नहीं], नाम = 'X') # [बैचसाइज़, SEQLEN]
Xo = tf.one_hot(X, ALPHASIZE, 1.0, 0.0) # [ BATCHSIZE, SEQLEN, ALPHASIZE ]# अपेक्षित आउटपुट = समान क्रम 1 से शिफ्ट हो गया क्योंकि हम अगले वर्ण की भविष्यवाणी करने की कोशिश कर रहे हैं
Y_ = tf. प्लेसहोल्डर (tf.uint8, [कोई नहीं, कोई नहीं], नाम = 'Y_') # [ बैच आकार, SEQLEN ]
Yo_ = tf.one_hot(Y_, ALPHASIZE, 1.0, 0.0) # [ BATCHSIZE, SEQLEN, ALPHASIZE ]# इनपुट स्थिति
हिन = tf. प्लेसहोल्डर (tf.float32, [कोई नहीं, आंतरिक* NLAYERS], नाम = 'हिन') # [ बैच आकार, आंतरिक * NLAYERS]

NLAYERS=GRU कोशिकाओं की 3 परतों का उपयोग करते हुए, अनियंत्रित SEQLEN=30 गुना# dynamic_rnn इनपुट के आकार से SEQLEN का अनुमान लगाता है Xo

onecell = rnn.GRUCell(INTERNALSIZE)
ड्रॉपसेल = rnn.DropoutWrapper(onecell, input_keep_prob=pkeep)
मल्टीसेल = rnn.MultiRNNCell([रेंज में _ के लिए ड्रॉपसेल (NLAYERS)], State_is_tuple=False)
मल्टीसेल = rnn.DropoutWrapper (मल्टीसेल, output_keep_prob = pkeep)
Yr, H = tf.nn.dynamic_rnn(multicell, Xo, dtype=tf.float32, Initial_state=Hin)# वर्ष: [बैचसाइज़, SEQLEN, INTERNALSIZE ]# H: [बैचसाइज़, INTERNALSIZE*NLAYERS ] # यह अंतिम स्थिति है क्रम में

मुझे पुन: उपयोग ध्वज के संबंध में कोई दस्तावेज नहीं मिल रहा है?

अग्रिम में धन्यवाद।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-285702372 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/ABtim6MOOCbx3RJEJe8PQBDXGVIXTGPmks5rkW_jgaJpZM4MWl4f
.

मुझे समझ में नहीं आता कि मुझे seq2seq ट्यूटोरियल मॉडल के साथ यह त्रुटि क्यों मिल रही है:

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

स्रोत

जहां सेल बनाया गया है

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

@ebrevdo इस मुद्दे पर वापस आने के लिए धन्यवाद। दुर्भाग्य से, सुझाया गया परिवर्तन मायने रखता है जैसे वे हैं, उपरोक्त त्रुटि के साथ। seq2seq ट्यूटोरियल के बारे में उपरोक्त टिप्पणी को देखते हुए, मुझे संदेह है कि हम सभी एक ही नाव में हैं?

क्या आप सुनिश्चित हैं कि यह वही त्रुटि है? कृपया इसे यहां कॉपी और पेस्ट करें।

मेरा बुरा, मैं बस परिवर्तन प्रक्रिया के माध्यम से प्रासंगिक कोड में फिर से (स्क्रैच से) चला गया और इसे प्रस्तावित के रूप में फिर से चलाया। त्रुटि वास्तव में हटा दी गई है और ओल्ड बार्ड अभी ठीक है

तो, thx, सुनिश्चित नहीं है कि मैं कल कहाँ गलत हो गया था, लेकिन यह स्पष्ट रूप से मुझ पर था।

Tensorflow 1.0 के रिलीज़ संस्करण का उपयोग करते समय और CPU मोड में MacOS पर काम करते समय मुझे एक ही समस्या का सामना करना पड़ा। भले ही "पुन: उपयोग" पैरामीटर जोड़ें

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)

आपका मल्टीसेल गलत दिखता है... आपको _ in . के लिए "सेल ()" का उपयोग करना चाहिए
श्रेणी(...)"

गुरु, 16 मार्च, 2017 को रात 8:29 बजे, cuiming [email protected] ने लिखा:

Tensorflow 1.0 . के रिलीज़ संस्करण का उपयोग करते समय मुझे उसी समस्या का सामना करना पड़ा
और सीपीयू मोड में मैकोज़ पर काम कर रहा है। भले ही "पुन: उपयोग" पैरामीटर जोड़ें

डीईएफ़ सेल ():
वापसी 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
.

मैं अनुवाद उदाहरण चलाने की कोशिश कर रहा था: python2.7 translation.py --data_dir data/ --train_dir train/ --size=256 --num_layers=2 --steps_per_checkpoint=50

ऐसा लगता है कि MultiRNNCell का उपयोग करने का तरीका सही है:
सेल = tf.contrib.rnn.MultiRNNCell([single_cell() for _ in range(num_layers)])

लेकिन मुझे वही त्रुटि मिली:
ValueError: आरएनएनसेल का पुन: उपयोग करने का प्रयासइसके पहले उपयोग की तुलना में एक अलग परिवर्तनीय दायरे के साथ। सेल का पहला प्रयोग 'embedding_attention_seq2seq/embedding_attention_decoder/attention_decoder/multi_rnn_cell/cell_0/gru_cell' के दायरे के साथ था, यह प्रयास 'embeding_attention_seq2seq/rnn/multi_rnn_cell/cell_0/gru_cell' के दायरे के साथ है। कृपया सेल का एक नया इंस्टेंस बनाएं यदि आप चाहते हैं कि यह वजन के एक अलग सेट का उपयोग करे। यदि आप पहले उपयोग कर रहे थे: MultiRNNCell([GRUCell(...)] * num_layers), इसमें बदलें: MultiRNNCell([GRUCell(...) for _ in range(num_layers)])। यदि इससे पहले आप एक ही सेल इंस्टेंस का उपयोग एक द्विदिश आरएनएन के फॉरवर्ड और रिवर्स सेल दोनों के रूप में कर रहे थे, तो बस दो इंस्टेंस बनाएं (एक फॉरवर्ड के लिए, एक रिवर्स के लिए)। मई 2017 में, हम मौजूदा संग्रहीत वज़न का उपयोग करने के लिए इस सेल के व्यवहार को बदलना शुरू कर देंगे, यदि कोई हो, जब इसे स्कोप = कोई नहीं कहा जाता है (जिससे मूक मॉडल गिरावट हो सकती है, इसलिए यह त्रुटि तब तक बनी रहेगी।)

@bowu - क्या आपको इसके साथ कोई भाग्य मिला है? यदि आपने इसे अभी तक नहीं आज़माया है, तो नवीनतम स्रोत से टेंसरफ़्लो को फिर से स्थापित करें। कुछ अन्य के बीच कुछ core_rnn फ़ाइलों में कुछ परिवर्तन हुए। मेरे लिए अब काम करता है।

@robmsylvester मैं नवीनतम स्रोत से tensorflow को पुनर्स्थापित करता हूं, फिर भी वही त्रुटि। मैं शाखा मास्टर पर था और नवीनतम प्रतिबद्धता commit 2a4811054a9e6b83e1f5a2705a92aab50e151b13 है। जब आप अपना रेपो बनाते हैं तो नवीनतम प्रतिबद्धता क्या होती है?

नमस्ते, मैं स्रोत का उपयोग करके निर्मित GPU का उपयोग करके Tensorflow r1.0 का उपयोग कर रहा हूं। मैं अनमॉडिफाइड Seq2Seq अनुवाद ट्यूटोरियल का अनुसरण करने का प्रयास कर रहा हूं, लेकिन मुझे वही त्रुटि मिल रही है। अर्थात

ValueError: आरएनएनसेल का पुन: उपयोग करने का प्रयासइसके पहले उपयोग की तुलना में एक अलग परिवर्तनीय दायरे के साथ। सेल का पहला प्रयोग 'embedding_attention_seq2seq/embedding_attention_decoder/attention_decoder/multi_rnn_cell/cell_0/gru_cell' के दायरे के साथ था, यह प्रयास 'embeding_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)])

समस्या को हल करने के लिए मैं क्या कर सकता हूँ?

उस कॉल में "reuse=tf.get_variable_scope().reuse" जोड़ना जहां GRUCell बनाया गया है, मदद नहीं करता है।

अनेक अनेक धन्यवाद!

@prashantserai - देखें कि क्या होता है यदि आप ऊपर से MultiRNNCell लाइन हटाते हैं, प्रभावी रूप से आपके नेटवर्क को केवल एक परत बनाते हैं। क्या यह तब काम करता है? यह MultiRNNCell में कहीं एक बग हो सकता है। मैंने इसके बारे में हाल ही में कहीं पढ़ा है, शायद स्टैक ओवरफ्लो पर।

यदि आप स्टैक्ड lstm/gru को स्वयं लागू करते हैं, तो आपको यह त्रुटि नहीं मिलती है, और आप समान कार्यक्षमता को लागू कर सकते हैं (वास्तव में अधिक, क्योंकि आप द्विदिश आर्किटेक्चर, अजीब अवशिष्ट और स्किप कनेक्शन आदि के साथ जो कुछ भी करना चाहते हैं उसे करने के लिए स्वतंत्र हैं, आदि) ।)

@robmsylvester वही त्रुटि तब भी बनी रही जब मैंने num_layers=1 के साथ प्रयास किया जो प्रभावी रूप से उस पंक्ति को छोड़ देना चाहिए। कोई अन्य विचार? इनपुट के लिए धन्यवाद।

हम्म। एक चीज जो मेरे सामने है वह संदर्भित विरासत seq2seq फ़ाइल में है:

encoder_cell = copy.deepcopy(cell)

इस लाइन का उपयोग किया गया प्रतीत होता है क्योंकि एन्कोडर और डिकोडर दोनों तरफ एक ही आर्किटेक्चर का उपयोग किया जाता है। वे सेल की एक प्रति बनाते हैं, फिर सेल तर्क को ध्यान डिकोडर एम्बेडिंग फ़ंक्शन के साथ पास करते हैं, फिर ध्यान डिकोडर को ही।

क्या होता है यदि आप अपनी seq2seq मॉडल फ़ाइल में स्पष्ट रूप से एन्कोडर सेल और डिकोडर सेल बनाते हैं और दोनों को विरासत पुस्तकालय फ़ाइल के साथ पास करते हैं, जिससे कार्यों और उनके तर्कों में छोटे समायोजन होते हैं?

@robmsylvester को कोशिकाओं के काम के दायरे में बदलाव नहीं करना चाहिए? यह अन्य दो उदाहरणों के लिए भी काम कर रहा है। मेरी राय में, यह एक बहुत ही बदसूरत समाधान होगा; एक क्लीनर समाधान मौजूद होना चाहिए; शायद हमें कुछ याद आ रहा है? (मुझे seq2seq ट्यूटोरियल पर भी यही त्रुटि मिली, उपरोक्त सभी समाधानों की कोशिश की)।

@ iamgroot42 - हाँ, वह 'समाधान' वास्तव में बहुत बदसूरत है, लेकिन इससे भी अधिक यह पता लगाने की कोशिश की जा रही है कि कोई समस्या कहाँ हो सकती है। मैं इसके साथ कुछ घंटों में खेलूंगा और देखूंगा कि क्या मैं कुछ नीचे ट्रैक कर सकता हूं।

वास्तव में, copy.deepcopy वहाँ है क्योंकि ये विरासती कार्य हैं और
हमारे पास उन्हें बनाए रखने/अद्यतन करने के लिए संसाधन नहीं हैं। यदि आप करना चाहते हैं
एक पश्च-संगत परिवर्तन पेश करें जो उपयोगकर्ता को एक प्रदान करने की अनुमति देता है
डिकोडिंग चरण के लिए दूसरा सेल, और यदि यह कोई नहीं है तो पर फ़ॉलबैक करने के लिए
डीपकॉपी, तो मुझे पीआर की समीक्षा करने में खुशी होगी। ध्यान रखें यह होगा
एक पिछड़ा संगत परिवर्तन होना चाहिए।

मंगलवार, 4 अप्रैल, 2017 को पूर्वाह्न 11:38 बजे, रॉब सिल्वेस्टर नोटिफिकेशन @github.com
लिखा था:

@iamgroot42 https://github.com/iamgroot42 - हाँ, वह 'समाधान' है
माना जाता है कि बहुत बदसूरत है, लेकिन इससे भी ज्यादा सिर्फ यह पता लगाने की कोशिश कर रहा है कि कोई मुद्दा कहां है
हो सकता है। मैं इसके साथ कुछ घंटों में खेलूंगा और देखूंगा कि क्या मैं कुछ ट्रैक कर सकता हूं
नीचे।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-291593289 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/ABtim1QHTDhOC_zT6cKtmUFPOit5Yjn7ks5rso5CgaJpZM4MWl4f
.

@ebrevdo - मैं इसके बारे में सोचूंगा। मेरे पास एक अनुवादक है जो इस के समान ही काम करता है लेकिन एक अलग वर्ग के माध्यम से कोशिकाओं को बनाता है जो जहां आप चाहते हैं, जहां आप चाहते हैं, अवशिष्ट परतों को सम्मिलित करने की अनुमति देता है, कॉन्सट बनाम योग के साथ इनपुट विलय, और कुछ अन्य चीजें। मुझे लगता है कि मैं स्थिर आरएनएन का उपयोग करके अपनी कक्षा को इस ट्यूटोरियल में आसानी से स्थानांतरित कर सकता हूं। मैं आपको बता दूँगा।

@ebrevdo मैं Red Hat पर Tensorflow r1.0 (tensorflow-1.0.1-cp36-cp36m-linux_x86_64) चला रहा हूं और गीथूब से अनुवाद ट्यूटोरियल का नवीनतम संस्करण है .. क्या वर्तमान में यह काम करने का कोई तरीका है?

यह दुर्भाग्यपूर्ण है कि अनुवाद ट्यूटोरियल TF 1.0 के साथ काम नहीं करता है। हमें इसे ठीक करना चाहिए। @lukaszkaiser क्या आप देख सकते हैं? हम एक नए ट्यूटोरियल पर काम कर रहे हैं लेकिन इसमें अभी कुछ सप्ताह बाकी हैं और काम करने के लिए TensorFlow (या TF 1.1 या 1.2) के एक रात्रिकालीन संस्करण की आवश्यकता होगी।

(लुकाज़; मेरे लिए विभिन्न टिप्पणियों से यह पहचानना मुश्किल है कि टीएफ 1.0 में ट्यूटोरियल का कौन सा हिस्सा दोषपूर्ण है। किसी भी मौके पर आप लाइन की पहचान कर सकते हैं और मैं इसे काम करने में मदद कर सकता हूं?)

@ebrevdo यह यह ट्यूटोरियल है। त्रुटि लाइनों के इस समूह में है। यहां पारित कोशिकाओं का उपयोग विरासत seq2seq मॉडल के पिछड़े और आगे दोनों चरणों के लिए किया जाता है, जो अलग-अलग क्षेत्रों के साथ समान कोशिकाओं के उपयोग के कारण एक त्रुटि फेंकता है।

@iamgroot42 क्या आप आवश्यक परिवर्तनों के साथ पीआर बनाना चाहते हैं? यह बहुत अच्छा होगा, मेरे पास वर्तमान में ऐसा करने के लिए साइकिल नहीं है। धन्यवाद!

मैंने देखा कि टीएफ 1.0 अनुवाद ट्यूटोरियल के नवीनतम संस्करण के साथ ठीक काम करता है यदि शाखा रिमोट/मूल/आर 1.0 पर स्रोत से संकलित किया जाता है

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

फिर TensorFlow बनाएं और इंस्टॉल करें, यह ठीक काम करता है।

शाखा रिमोट/मूल/आर 1.1 पर इसमें "अलग परिवर्तनीय दायरा" त्रुटि है।
मैंने कोड को संशोधित किया जैसा कि @robmsylvester ने सुझाया था

क्या होता है यदि आप अपनी seq2seq मॉडल फ़ाइल में स्पष्ट रूप से एन्कोडर सेल और डिकोडर सेल बनाते हैं और दोनों को विरासत पुस्तकालय फ़ाइल के साथ पास करते हैं, जिससे कार्यों और उनके तर्कों में छोटे समायोजन होते हैं?

और यह अब मेरे लिए काम करता है।

@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 बिल्कुल नहीं जानते, लेकिन आप जो मिले वह एक और मुद्दा प्रतीत होता है।

@prashantserai यदि यह केवल तभी विफल हो जाता है जब आप डीकोड करते हैं, तो शायद इसका बैच आकार का उपयोग करने के साथ कुछ करना है? यदि आप प्रशिक्षण के दौरान बैच का आकार घटाकर एक कर देते हैं तो क्या मॉडल अभी भी प्रशिक्षित होता है?

@bowu यहां वही त्रुटि है। Mac OX Sierra, TensorFlow 1.1.0-rc1, Python 2.7.10 और Python 3.6.1।

@robmsylvester इसने एक के बैच आकार के साथ भी सफलतापूर्वक प्रशिक्षण लिया, लेकिन उसी तरह या इसी तरह से डिकोडिंग के दौरान विफल रहा .. यहां एक पूर्ण ट्रेसबैक है .. कारण मैं इसे एक कनेक्टेड त्रुटि के रूप में सोच रहा था क्योंकि इसका संदर्भ था 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 मैंने डिकोडिंग की कोशिश की और यह ठीक काम करता है। मैं बस encoder_cell arg को फ़ंक्शन tf.contrib.legacy_seq2seq.embedding_attention_seq2seq में जोड़ता हूं और translate/seq2seq_model.py में सेल बनाता हूं और इसे फ़ंक्शन में पास करता हूं, जिसे फ़ंक्शन seq2seq_f में कॉल किया गया था। आपने अपना कोड कैसे बदला?

@oxwsds @robmsylvester @ebrevdo
मेरे पास अंत में कुछ ऐसा है जो अब काम कर रहा है (मेरा मतलब है, मेरे सिंगल लेयर 256 यूनिट नेटवर्क के परिणाम भयावह हैं, लेकिन शायद यह सिर्फ इसलिए है क्योंकि नेटवर्क अल्ट्रा लाइट वेट है और मैंने पैरा को बिल्कुल भी ट्यून नहीं किया है)
आप सभी का बहुत धन्यवाद...!!!!!

_इसके अंत में मेरे विचार हैं:_

@oxwsds टिप्पणी करते हैं कि जब Tensorflow को शाखा से संकलित किया जाता है तो ट्यूटोरियल (इसके वर्तमान रूप में) संशोधन की आवश्यकता के बिना काम करता है रिमोट/मूल/r1.0 TRUE था । हालाँकि, दुखद बात यह थी कि मेरे पास Tensorflow का संस्करण था जिसके लिए Tensorflow कोड के भीतर संशोधनों की आवश्यकता थी, और Remotes/origin/r1.0 में संस्करण दोनों को समान रूप से लेबल किया गया था।

@robmsylvester टिप्पणी में ठीक है (नीचे कॉपी किया गया) टेन्सफोर्लो के मेरे संस्करण के लिए काम किया जहां ट्यूटोरियल बॉक्स से बाहर काम नहीं करता था (और मुझे लगता है कि टीएफ 1.1 के लिए भी काम करना चाहिए)। इसे लागू करना थोड़ा गड़बड़ है, लेकिन मैं इसे कर सकता था, जो कुछ कह रहा है :-P
इससे पहले मेरी पिछली दो टिप्पणियों में त्रुटि मेरी गलती के कारण हुई थी। एक डमी की तरह, मैं केवल प्रशिक्षण के दौरान परतों और छिपी इकाइयों के मापदंडों को निर्दिष्ट कर रहा था, मैं डिकोडिंग के दौरान चूक का उपयोग करने के लिए कोड छोड़ रहा था। (ट्यूटोरियल का यह भाग थोड़ा अधिक डमी प्रूफ हो सकता है: https://www.tensorflow.org/tutorials/seq2seq#lets_run_it )

हम्म। एक चीज जो मेरे सामने है वह संदर्भित विरासत seq2seq फ़ाइल में है:

एन्कोडर_सेल = कॉपी। डीपकॉपी (सेल)

इस लाइन का उपयोग किया गया प्रतीत होता है क्योंकि एन्कोडर और डिकोडर दोनों तरफ एक ही आर्किटेक्चर का उपयोग किया जाता है। वे सेल की एक प्रति बनाते हैं, फिर सेल तर्क को ध्यान डिकोडर एम्बेडिंग फ़ंक्शन के साथ पास करते हैं, फिर ध्यान डिकोडर को ही।

क्या होता है यदि आप अपनी seq2seq मॉडल फ़ाइल में स्पष्ट रूप से एन्कोडर सेल और डिकोडर सेल बनाते हैं और दोनों को विरासत पुस्तकालय फ़ाइल के साथ पास करते हैं, जिससे कार्यों और उनके तर्कों में छोटे समायोजन होते हैं?

प्रतिपुष्टि के लिए धन्यवाद! लगता है TF . के बीच कुछ अलग है
पीपीआई पर और उस टैग पर? गुनहान, क्या यह संभव है?

सोम, अप्रैल 10, 2017 को रात 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 हैशाखा रिमोट/मूल/आर 1.0 से संकलित TRUE था । दुखद बिट
हालाँकि यह कि Tensorflow का संस्करण मेरे पास था जिसके लिए संशोधन किया गया था
Tensorflow कोड के भीतर की जरूरत थी, और रिमोट/मूल/r1.0 . में संस्करण
दोनों को समान रूप से लेबल किया गया था।

@robmsylvester https://github.com/robmsylvester की टिप्पणी में सुधार करें
(नीचे कॉपी किया गया) Tensorflow के मेरे संस्करण के लिए काम किया जहां ट्यूटोरियल
बॉक्स से बाहर काम नहीं किया (और मुझे लगता है कि टीएफ 1.1 के लिए भी काम करना चाहिए)। यह है
लागू करने के लिए थोड़ा गन्दा, लेकिन मैं इसे कर सकता था, जो कुछ कह रहा है
:-पी
इससे पहले मेरी पिछली दो टिप्पणियों में त्रुटि मेरी गलती के कारण हुई थी। पसंद
एक डमी, मैं केवल परतों और छिपी इकाइयों के मापदंडों को निर्दिष्ट कर रहा था
प्रशिक्षण के दौरान, मैं डिकोडिंग के दौरान चूक का उपयोग करने के लिए कोड छोड़ रहा था। (यहट्यूटोरियल का हिस्सा थोड़ा और डमी सबूत हो सकता है:https://www.tensorflow.org/tutorials/seq2seq#lets_run_ithttps://www.tensorflow.org/tutorials/seq2seq#lets_run_it )

हम्म। एक बात जो मेरे सामने है वह संदर्भित विरासत seq2seq . में है
फ़ाइल:

एन्कोडर_सेल = कॉपी। डीपकॉपी (सेल)

यह रेखा प्रयुक्त प्रतीत होती है क्योंकि दोनों पर एक ही वास्तुकला का प्रयोग किया जाता है
एन्कोडर और डिकोडर पक्ष। वे सेल की एक कॉपी बनाते हैं, फिर उसे पास करते हैं
ध्यान डिकोडर एम्बेडिंग फ़ंक्शन के साथ सेल तर्क, फिर करने के लिए
ध्यान डिकोडर ही।

क्या होता है यदि आप स्पष्ट रूप से एन्कोडर सेल और डिकोडर बनाते हैं
अपनी seq2seq मॉडल फ़ाइल में सेल करें और दोनों को विरासत पुस्तकालय में पास करें
फ़ाइल, कार्यों और उनके तर्कों में छोटे समायोजन करना?

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-293143828 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/ABtimxvcfFnbWbpj7aUs3BUjwGEFj6p5ks5ruvvygaJpZM4MWl4f
.

जानकारी के लिए मुझे 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)

फिर, निम्न कोड के साथ, मॉडल बनाना ठीक था, लेकिन मैं वेरिएबल को किसी अन्य मॉडल के साथ साझा नहीं कर सका। (उदाहरण के लिए, यदि आप टेंसर साझा करने के लिए एक ट्रेन_मॉडल और एक वैध_मॉडल बनाते हैं, तो यह विफल हो जाएगा)

    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 का उपयोग lstm_cell tensorflow/models/tutorials/rnn/ptb/ptb_word_lm.py#L112 में फ़ंक्शन होने के लिए किया। मेरे पास अब है:

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)

यह अब पूरी तरह से काम कर रहा है

इस चीज़ को चलाने की कोशिश कर रहा है, जिसके परिणामस्वरूप एक ही त्रुटि होती है:

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 क्या आपने https://github.com/tensorflow/models/blob/master/tutorials/rnn/ptb/ptb_word_lm.py#L112 के फ़ंक्शन का उपयोग किया है जिसका मैंने अपनी पोस्ट के अंत में उल्लेख किया है (अब अधिक स्पष्ट होने के लिए संपादित किया गया है) )

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

इसने मेरी समस्या हल कर दी

Tensorflow के पुराने संस्करण को स्थापित करके इस समस्या को ठीक करने के लिए प्रबंधित:
pip install -Iv tensorflow==1.0

seq2seq ट्यूटोरियल निष्पादित करते समय मुझे त्रुटि मिल रही थी

@ebrevdo ने जो कहा, उसके संबंध में, मुझे लगता है कि समाधान विरासत seq2seq कोड को ठीक करना नहीं है, बल्कि इसके बजाय contrib.seq2seq पैकेज का उपयोग करने के लिए ट्यूटोरियल को अपडेट करना है, जिसे सक्रिय रूप से बनाए रखा जाता है। यह काफी मनोबल गिराने वाला होता है जब आपके द्वारा चलाए गए पहले टेंसरफ़्लो प्रोग्राम में त्रुटियों का एक समूह होता है। अगर मेरे पास इस सप्ताह कुछ समय है, तो मैं एक पीआर जमा करूंगा।

हम एक नए seq2seq ट्यूटोरियल पर काम कर रहे हैं। हमने के अंत तक रिलीज होने की उम्मीद की थी
पिछले महीने लेकिन देरी हो रही है। यह नए एपीआई का उपयोग करेगा।

1 मई, 2017 को सुबह 8:07 बजे, "काइल टीग" नोटिफिकेशन @github.com ने लिखा:

@ebrevdo https://github.com/ebrevdo ने जो कहा, उसके संबंध में, मुझे लगता है
समाधान विरासत seq2seq कोड को ठीक करने के लिए नहीं है, बल्कि अद्यतन करने के लिए है
इसके बजाय contrib.seq2seq पैकेज का उपयोग करने के लिए ट्यूटोरियल, जो सक्रिय रूप से है
बनाए रखा। जब आप पहला टेंसरफ़्लो प्रोग्राम करते हैं तो यह काफी मनोबल गिराने वाला होता है
कभी रन थूक त्रुटियों का एक गुच्छा। अगर मेरे पास इस सप्ताह कुछ समय है, तो मैं
एक जनसंपर्क प्रस्तुत करें।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-298350307 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/ABtim587xZx9Gi4-yXmwccSum8_Trc1oks5r1fUogaJpZM4MWl4f
.

@ebrevdo tensorflow1.1 वेबसाइट पर अनुक्रम_to_sequence मॉडल चलाते समय मुझे वही त्रुटि मिलती है। और मैंने 'पुन: उपयोग' पैरामीटर का उपयोग करने का प्रयास किया है लेकिन असफल रहा। क्या आप मुझे बता सकते हैं कि नया seq2seq ट्यूटोरियल कब जारी किया जाएगा?

एक ही समय में tf 1.2 जैसा दिखता है, क्योंकि हम कुछ नए पर भरोसा करेंगे
उस रिलीज की विशेषताएं।

4 मई, 2017 को रात 9:16 बजे, " njuzrs " [email protected] ने लिखा:

@ebrevdo https://github.com/ebrevdo दौड़ते समय मुझे वही त्रुटि मिलती है
tensorflow1.1 वेबसाइट पर अनुक्रम_to_sequence मॉडल। और मेरे पास कोशिश है
'पुन: उपयोग' पैरामीटर का उपयोग करने के लिए लेकिन असफल रहा। क्या आप मुझे बता सकते हैं जब नया seq2seq
ट्यूटोरियल जारी किया जाएगा?

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-299366774 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/ABtim8_kFTM7-SsXQAA-Ar0dfhHMGT0Zks5r2qKngaJpZM4MWl4f
.

@ebrevdo मैं भी उसी मुद्दे का सामना कर रहा हूं और seq2seq के साथ प्रगति करने में असमर्थ हूं। यह वास्तव में मददगार होगा यदि आप हमें बता सकते हैं कि एक नए ट्यूटोरियल के लिए संभावित तिथि क्या है।
आपकी सहायता के लिए धन्यवाद।

pip install tensorflow==1.0 (Tensorflow 1.0) का उपयोग करके इंस्टॉल करना मेरे लिए काम कर रहा है (अनुवाद ट्यूटोरियल)।

मेरे पास संस्करण 1.1.0-आरसी2 है।

TF1.2 इस समस्या का समाधान करेगा? कृपया मेरी मदद करें कि मॉडल का प्रशिक्षण कैसे जारी रखें। TF 1.0 काम करता है लेकिन इसमें कई GPU के लिए devicewrapper api नहीं है।

टेंसर फ्लो 1.1 के साथ भी यही समस्या है। अभी भी एक समाधान पर काम कर रहा है

मैंने कई चीजों की कोशिश की, अंत में मैं टेंसरफ्लो 1.1 का उपयोग करने में सक्षम था लेकिन इन परिवर्तनों को करना पड़ा: (उपरोक्त Tshzzz के आधार पर)

हटाए इसे:
multicell = rnn.MultiRNNCell([dropcell]*NLAYERS, state_is_tuple=False)

और इसे जोड़ें:
कोशिकाएं = []
_ इन रेंज (NLAYERS) के लिए:
सेल = rnn.DropoutWrapper(tf.contrib.rnn.GRUCell(INTERNALSIZE), input_keep_prob=pkeep)
सेल.एपेंड (सेल)
मल्टीसेल = rnn.MultiRNNCell(सेल, State_is_tuple=False)

@ebrevdo बधाई हो, TF 1.2 अभी जारी हुआ - क्या नया ट्यूटोरियल भी कहीं जारी किया गया था या इसे जल्द ही जारी किया जा रहा है?

धन्यवाद

इसके जारी होने पर हम एक घोषणा करने की योजना बनाएंगे। इस पर काम करते हुए।

19 मई, 2017 को शाम 7:02 बजे, "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
.

tensorflow-gpu==1.1.0 का उपयोग करने वाले किसी भी व्यक्ति के लिए और यह त्रुटि प्राप्त करने के लिए, pip install tensorflow-gpu==1.0.0 के माध्यम से 1.0.0 पर स्विच करने से समस्या ठीक नहीं होगी, कम से कम मेरे लिए काम नहीं किया।

मैं मैक और उबंटू दोनों पर इस मुद्दे में भाग गया और स्रोत से संकलन दोनों बार काम किया। इसलिए:
पाइप स्थापित करें https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.0.0-cp34-cp34m-linux_x86_64.whl

@ajaanbaahu अभी भी tf1.2 नए seq2seq ट्यूटोरियल की प्रतीक्षा कर रहा है।

इसने मेरे लिए pip install tensorflow==1.0 का उपयोग करके काम किया।

tf r1.2 के लिए, डीपकॉपी त्रुटि मिली। अनुक्रम मॉडल त्रुटि के क्रम में सूचीबद्ध के रूप में #1050

धोखेबाज़ के रूप में, मैं अपनी कुछ राय रखता हूं।
निम्नलिखित कोड इसी तरह की गलती को उत्पन्न करेगा:
(मेरे कोड का टुकड़ा)

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)

उन समाधानों में से किसी ने भी मेरे लिए Tensorflow 1.1 के साथ काम नहीं किया

मैं seq2seq मॉडल का उपयोग $ MultiRNNCell कोशिकाओं के साथ कर रहा हूं।

मुझे 1.0.1 पर वापस जाना पड़ा: pip3 install tensorflow==1.0

Legacy_seq2seq.rnn_decoder() के साथ काम करते समय किसी के पास ये समस्याएं हैं?

@oxwsds जैसा कि आपने कहा, मैं tf.contrib.legacy_seq2seq.embeding_attention_seq2seq के इनपुट आर्ग्स सेल को दो अलग-अलग सेल {encoder_cells, decoder_cells} में बदल देता हूं। अंत में, मुझे seq2seq मॉडल काम करता है। 73200 सेट के बाद, मुझे घबराहट होती है 5.54।
फिर मैं डिकोड भाग चलाता हूं,

संयुक्त राज्य अमेरिका के राष्ट्रपति कौन है?
क्वी इस्ट ले प्रेसिडेंट डेस एटैट्स-यूनिस?

समस्या हल हो गई। धन्यवाद।

@doncat99
ऐसा लगता है कि copy.deepcopy(cell) में seq2seq.py प्रभाव नहीं डालता है।
इसलिए मैं संबंधित भाग को 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)

@ supermeatboy82 , क्या आप अपना कोड साझा कर सकते हैं?

Tensorflow 1.2.0 में अपग्रेड करना और सूची गुणन के बजाय लूप में कोशिकाओं को उत्पन्न करना मेरे लिए यह तय करता है।

Transl.py चलाते समय TF1.2 के साथ त्रुटि मिली, विवरण:
नाम: GeForce GTX 1080 Ti
मेजर: 6 माइनर: 1 मेमोरीक्लॉकरेट (गीगाहर्ट्ज) 1.582
पीसीआईबसआईडी 0000:02: 00.0
कुल मेमोरी: 10.91GiB
फ्री मेमोरी: 10.76GiB
2017-06-22 09:15:04.485252: मैं tensorflow/core/common_runtime/gpu/gpu_device.cc:961] DMA: 0
2017-06-22 09:15:04.485256: मैं tensorflow/core/common_runtime/gpu/gpu_device.cc:971] 0: Y
2017-06-22 09:15:04.485265: मैं tensorflow/core/common_runtime/gpu/gpu_device.cc:1030] TensorFlow डिवाइस बनाना (/gpu:0) -> (डिवाइस: 0, नाम: GeForce GTX 1080 Ti, pci बस आईडी: 0000:02: 00.0)
1024 इकाइयों की 3 परतें बनाना।
ट्रेसबैक (सबसे हालिया कॉल अंतिम):
फ़ाइल "translate.py", लाइन 322, in
tf.app.run()
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/python/platform/app.py", लाइन 48, चल रही है
_sys.exit(मुख्य(_sys.argv[:1] + flags_passthrough))
फ़ाइल "translate.py", लाइन 319, मुख्य में
रेल गाडी()
फ़ाइल "translate.py", लाइन 178, ट्रेन में
मॉडल = create_model (सत्र, गलत)
फ़ाइल "translate.py", लाइन 136, create_model . में
डीटाइप = डीटाइप)
फ़ाइल "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", लाइन 179, __init__ में
सॉफ्टमैक्स_लॉस_फंक्शन = सॉफ्टमैक्स_लॉस_फंक्शन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", लाइन 1206, model_with_buckets में
decoder_inputs[:bucket[1]])
फ़ाइल "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", लाइन 178, में
लैम्ब्डा एक्स, वाई: seq2seq_f (एक्स, वाई, गलत),
फ़ाइल "/data/research/github/dl/tensorflow/tensorflow/models/tutorials/rnn/translate/seq2seq_model.py", पंक्ति 142, seq2seq_f में
डीटाइप = डीटाइप)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py", लाइन 848, एम्बेडिंग_अटेंशन_seq2seq में
एन्कोडर_सेल = कॉपी। डीपकॉपी (सेल)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 174, डीपकॉपी में
वाई = कॉपियर (ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/site-packages/tensorflow/python/layers/base.py", लाइन 476, __deepcopy__ में
setattr(result, k, copy.deepcopy(v, memo))
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 163, डीपकॉपी में
y = कॉपियर (x, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 230, _deepcopy_list में
y.append (डीपकॉपी (ए, मेमो))
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 190, डीपकॉपी में
y = _reconstruct(x, rv, 1, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 334, _reconstruct में
राज्य = डीपकॉपी (राज्य, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 163, डीपकॉपी में
y = कॉपियर (x, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 257, _deepcopy_dict में
y [डीपकॉपी (कुंजी, मेमो)] = डीपकॉपी (मान, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 190, डीपकॉपी में
y = _reconstruct(x, rv, 1, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 334, _reconstruct में
राज्य = डीपकॉपी (राज्य, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 163, डीपकॉपी में
y = कॉपियर (x, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 257, _deepcopy_dict में
y [डीपकॉपी (कुंजी, मेमो)] = डीपकॉपी (मान, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 190, डीपकॉपी में
y = _reconstruct(x, rv, 1, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 334, _reconstruct में
राज्य = डीपकॉपी (राज्य, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 163, डीपकॉपी में
y = कॉपियर (x, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 257, _deepcopy_dict में
y [डीपकॉपी (कुंजी, मेमो)] = डीपकॉपी (मान, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 190, डीपकॉपी में
y = _reconstruct(x, rv, 1, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 334, _reconstruct में
राज्य = डीपकॉपी (राज्य, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 163, डीपकॉपी में
y = कॉपियर (x, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 257, _deepcopy_dict में
y [डीपकॉपी (कुंजी, मेमो)] = डीपकॉपी (मान, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 163, डीपकॉपी में
y = कॉपियर (x, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 257, _deepcopy_dict में
y [डीपकॉपी (कुंजी, मेमो)] = डीपकॉपी (मान, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 163, डीपकॉपी में
y = कॉपियर (x, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 230, _deepcopy_list में
y.append (डीपकॉपी (ए, मेमो))
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 190, डीपकॉपी में
y = _reconstruct(x, rv, 1, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 334, _reconstruct में
राज्य = डीपकॉपी (राज्य, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 163, डीपकॉपी में
y = कॉपियर (x, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 257, _deepcopy_dict में
y [डीपकॉपी (कुंजी, मेमो)] = डीपकॉपी (मान, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 190, डीपकॉपी में
y = _reconstruct(x, rv, 1, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 334, _reconstruct में
राज्य = डीपकॉपी (राज्य, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 163, डीपकॉपी में
y = कॉपियर (x, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 257, _deepcopy_dict में
y [डीपकॉपी (कुंजी, मेमो)] = डीपकॉपी (मान, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 190, डीपकॉपी में
y = _reconstruct(x, rv, 1, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 334, _reconstruct में
राज्य = डीपकॉपी (राज्य, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 163, डीपकॉपी में
y = कॉपियर (x, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 257, _deepcopy_dict में
y [डीपकॉपी (कुंजी, मेमो)] = डीपकॉपी (मान, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 163, डीपकॉपी में
y = कॉपियर (x, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 230, _deepcopy_list में
y.append (डीपकॉपी (ए, मेमो))
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 163, डीपकॉपी में
y = कॉपियर (x, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 237, _deepcopy_tuple में
y.append (डीपकॉपी (ए, मेमो))
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 163, डीपकॉपी में
y = कॉपियर (x, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 257, _deepcopy_dict में
y [डीपकॉपी (कुंजी, मेमो)] = डीपकॉपी (मान, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 190, डीपकॉपी में
y = _reconstruct(x, rv, 1, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 334, _reconstruct में
राज्य = डीपकॉपी (राज्य, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 163, डीपकॉपी में
y = कॉपियर (x, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 257, _deepcopy_dict में
y [डीपकॉपी (कुंजी, मेमो)] = डीपकॉपी (मान, मेमो)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 190, डीपकॉपी में
y = _reconstruct(x, rv, 1, ज्ञापन)
फ़ाइल "/home/lscm/opt/anaconda2/lib/python2.7/copy.py", लाइन 343, _reconstruct में
y.__dict__.अद्यतन (राज्य)
विशेषता त्रुटि: 'कोई नहीं' ऑब्जेक्ट में कोई विशेषता नहीं है 'अपडेट'

ट्यूटोरियल में अनुवाद मॉडल में self_test() चलाते समय मुझे copy.deepcopy(cell) में embedding_attention_seq2seq() की वजह से हुई त्रुटि भी मिली।
मैंने seq2seq_f() में Seq2SeqModel में कोड को निम्नानुसार बदलने की कोशिश की:

    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)

फिर अब कोई त्रुटि नहीं है।
लेकिन एक धोखेबाज़ के रूप में मुझे नहीं पता कि यहां कोड पहले की तरह काम करते हैं और ऐसा लगता है कि परिवर्तन मॉडल को धीमा कर देते हैं।

मैं सभी को अपडेट करना चाहूंगा कि मैंने टेंसरफ़्लो को 1.0.0 (टेंसरफ़्लो-जीपीयू) में डाउनग्रेड किया और यह मेरे लिए काम कर रहा है। मॉडल उम्मीद के मुताबिक प्रदर्शन कर रहे हैं। मुझे लगता है कि 1.0.0 का सीपीयू संस्करण अपेक्षित रूप से कार्य करना चाहिए? या?।
धन्यवाद :)

हाय दोस्तों, मुझे नहीं पता कि आप अभी भी इसमें रुचि रखते हैं, लेकिन मैंने पाया कि समस्या embedding_attention_seq2seq फ़ंक्शन में पैरा के रूप में पारित सेल की प्रतिलिपि बनाने के संचालन से संबंधित है। ऐसा इसलिए है क्योंकि एन्कोडर और डिकोडर दोनों के लिए समान सेल परिभाषा का उपयोग किया जाता है। मुझे लगता है कि ट्यूटोरियल को बहिष्कृत कर दिया गया है क्योंकि यह एक गतिशील seq2seq के विपरीत बाल्टी के साथ एक seq2seq मॉडल का उपयोग करता है। लेकिन, मैं एक संशोधित फ़ंक्शन चिपका रहा हूं जो काम करता है। फ़ंक्शन tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py फ़ाइल में अपडेट किया गया है।

धन्यवाद,
फैबियो

अजगर
डीईएफ़ एम्बेडिंग_अटेंशन_सेक2सेक(एनकोडर_इनपुट्स,
डिकोडर_इनपुट्स,
एनसी_सेल,
dec_cell,
num_encoder_symbols,
num_decoder_symbols,
एम्बेडिंग_साइज़,
num_heads=1,
आउटपुट_प्रोजेक्शन = कोई नहीं,
Feed_previous=गलत,
dtype=कोई नहीं,
दायरा = कोई नहीं,
प्रारंभिक_स्टेट_अटेंशन = गलत):
"""सीक्वेंस-टू-सीक्वेंस मॉडल को ध्यान से एम्बेड करना।

यह मॉडल पहले encoder_inputs को एक नव निर्मित एम्बेडिंग (आकार का) द्वारा एम्बेड करता है
[num_encoder_symbols x input_size])। फिर यह एन्कोड करने के लिए एक आरएनएन चलाता है
एक राज्य वेक्टर में एम्बेडेड एन्कोडर_इनपुट। यह इसके आउटपुट रखता है
आरएनएन हर कदम पर बाद में ध्यान देने के लिए उपयोग करने के लिए। इसके बाद, यह decoder_inputs एम्बेड करता है
एक और नव निर्मित एम्बेडिंग द्वारा (आकार का [num_decoder_symbols x
इनपुट_साइज])। फिर यह ध्यान डिकोडर चलाता है, जिसे अंतिम के साथ आरंभ किया जाता है
एन्कोडर स्थिति, एम्बेडेड डिकोडर_इनपुट पर और एन्कोडर आउटपुट में भाग लेना।

चेतावनी: जब output_projection कोई नहीं है, ध्यान वैक्टर का आकार
और चरों को num_decoder_symbols के समानुपाती बनाया जाएगा, बड़े हो सकते हैं।

आर्ग्स:
encoder_inputs: आकार के 1D int32 टेंसर की एक सूची [batch_size]।
decoder_inputs: आकार के 1D int32 टेंसर की एक सूची [batch_size]।
सेल: tf.nn.rnn_cell.RNNCसेल सेल फ़ंक्शन और आकार को परिभाषित करता है।
num_encoder_symbols: पूर्णांक; एन्कोडर पक्ष पर प्रतीकों की संख्या।
num_decoder_symbols: पूर्णांक; डिकोडर पक्ष पर प्रतीकों की संख्या।
एम्बेडिंग_साइज़: पूर्णांक, प्रत्येक प्रतीक के लिए एम्बेडिंग वेक्टर की लंबाई।
num_heads: अटेंशन_स्टेट्स से पढ़ने वाले अटेंशन हेड्स की संख्या।
आउटपुट_प्रोजेक्शन: आउटपुट प्रोजेक्शन वेट का कोई नहीं या एक जोड़ी (डब्ल्यू, बी) और
पक्षपात; W का आकार है [output_size x num_decoder_symbols] और B का है
आकार [num_decoder_symbols]; यदि प्रदान किया गया हो और Feed_previous=True, प्रत्येक
खिलाया गया पिछला आउटपुट पहले W से गुणा किया जाएगा और B जोड़ा जाएगा।
Feed_previous: बूलियन या अदिश बूलियन टेंसर; अगर सच है, केवल पहला
decoder_inputs ("GO" प्रतीक), और अन्य सभी डिकोडर का उपयोग किया जाएगा
इनपुट पिछले आउटपुट से लिए जाएंगे (जैसा कि एम्बेडिंग_आरएनएन_डिकोडर में है)।
यदि गलत है, तो decoder_inputs दिए गए (मानक डिकोडर केस) के रूप में उपयोग किया जाता है।
dtype: प्रारंभिक आरएनएन राज्य का प्रकार (डिफ़ॉल्ट: tf.float32)।
दायरा: बनाए गए सबग्राफ के लिए वेरिएबलस्कोप; करने के लिए चूक
"embedding_attention_seq2seq"।
प्रारंभिक_स्टेट_अटेंशन: यदि गलत (डिफ़ॉल्ट) है, तो प्रारंभिक ध्यान शून्य है।
यदि सही है, तो प्रारंभिक अवस्था से ध्यान आरंभ करें और ध्यान दें
राज्यों।

रिटर्न:
फॉर्म का एक टपल (आउटपुट, राज्य), जहां:
आउटपुट: 2D Tensors के decoder_inputs के समान लंबाई की एक सूची
आकार [बैच_साइज़ x num_decoder_symbols] जिसमें उत्पन्न होता है
आउटपुट
राज्य: अंतिम समय-चरण में प्रत्येक डिकोडर सेल की स्थिति।
यह आकार का एक 2D टेंसर है [batch_size x cell.state_size]।
"""
वेरिएबल_स्कोप के साथ। वेरिएबल_स्कोप (
स्कोप या "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 समारोह के लिए धन्यवाद। वास्तव में मददगार लगता है। मैंने यह भी देखा कि ट्यूटोरियल बहिष्कृत है। मैं अभी भी एक आधिकारिक ट्यूटोरियल रिलीज की प्रतीक्षा कर रहा हूं। ऐसा लगता है कि आपने नई एपीआई का इस्तेमाल किया है। क्या आपके पास कोई कोड है जिसे नए एपीआई पर कोडिंग शुरू करने के लिए देखा जा सकता है?
किसी भी मदद की सराहना की जाती है। एक बार फिर आपका धन्यवाद :)

@ syw2014 क्या आपने अपनी समस्या ठीक की?

@ w268wang अभी तक नहीं, अभी भी अन्य समाधानों की प्रतीक्षा कर रहा है, लेकिन @Miopas की टिप्पणियों का प्रयास हो सकता है, और मैं @fabiofumarola के समाधान की कोशिश कर रहा हूं

यह कहता है TypeError: embedding_attention_seq2seq() missing 1 required positional argument: 'dec_cell'
अद्यतन का उपयोग करने के बाद @fabiofumarola ने पोस्ट किया। क्या आप लोग कृपया मेरी मदद कर सकते हैं?

हां क्योंकि मैंने जो अपडेट प्रस्तावित किया है उसके लिए आपको इसे बदलने की आवश्यकता है
Embedding_attention_seq2seq समारोह। यदि आप आप में स्रोत फ़ाइल में जाते हैं
टेंसरफ़्लो रिलीज़ आप स्वयं की विधि परिभाषा को बदल सकते हैं।

रविवार, 2 जुलाई 2017 को 18:15 बजे, sachinh35 [email protected] trote

यह कहता है TypeError: Embedding_attention_seq2seq() लापता 1 आवश्यक
स्थितीय तर्क: 'dec_cell'

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312500996 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/ABepUEc3W8m5CVDQGnCLu4dcJVFwwLDZks5sJ8IOgaJpZM4MWl4f
.

>

जीमेल मोबाइल से भेजा गया

हाँ मैंने वही किया। मैंने टेंसरफ़्लो रिलीज़ में seq2seq.py फ़ाइल में फ़ंक्शन को बदल दिया। फिर भी मुझे वही त्रुटि मिल रही है। क्या समारोह के लिए एक और तर्क है?

हां, अब आपके कोड में आपको rnn_cells को निर्दिष्ट करने की आवश्यकता है। एन्कोडर के लिए एक
और दूसरा डिकोडर के लिए।

सूर्य, 2 जुलाई 2017 को 20:54 बजे, fabio fumarola [email protected] ने लिखा:

हां

रविवार, 2 जुलाई 2017 को 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
.

>

जीमेल मोबाइल से भेजा गया

मैं इसके लिए बिल्कुल नया हूं। शायद यह एक बहुत ही बुनियादी सवाल है लेकिन क्या आप बता सकते हैं कि इस कोड में डिकोडर सेल के रूप में कौन सा तर्क पारित किया जाना है? मैं seq2seq को विकसित करने का प्रयास कर रहा हूं जैसा कि टेंसरफ़्लो ट्यूटोरियल में स्वयं के डेटासेट का उपयोग करके दिखाया गया है।

`
__भविष्य__ से निरपेक्ष_आयात आयात करें
__भविष्य__ आयात प्रभाग से
__भविष्य__ से प्रिंट_फंक्शन आयात करें

यादृच्छिक आयात करें

np . के रूप में numpy आयात करें
छह से। आयात xrange # पाइलिंट: अक्षम = पुनर्परिभाषित-बिल्टिन
tf . के रूप में टेंसरफ़्लो आयात करें

आयात data_utils

वर्ग Seq2SeqModel (वस्तु):
def __init__(स्वयं,
स्रोत_वोकैब_आकार,
लक्ष्य_वोकैब_आकार,
बाल्टी,
आकार,
num_layers,
max_gradient_norm,
बैच का आकार,
सीखने की दर,
Learning_rate_decay_factor,
use_lstm=गलत,
num_samples=512,
आगे_केवल=गलत,
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())

डीईएफ़ चरण (स्वयं, सत्र, एन्कोडर_इनपुट्स, डिकोडर_इनपुट्स, टारगेट_वेट्स,
बकेट_आईडी, फॉरवर्ड_ओनली):

# 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 (स्वयं, डेटा, बाल्टी_आईडी):

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`

स्टैक ओवरफ्लो के लिए यह एक अच्छा सवाल है।

3 जुलाई, 2017 को सुबह 8:46 बजे, " sachinh35 " [email protected] ने लिखा:

मैं इसके लिए बिल्कुल नया हूं। शायद यह एक बहुत ही बुनियादी सवाल है लेकिन क्या आप कर सकते हैं?
बताएं कि इस कोड में डिकोडर सेल के रूप में कौन सा तर्क पारित किया जाना है? मैं हूं
seq2seq को विकसित करने की कोशिश कर रहा है जैसा कि टेंसरफ़्लो ट्यूटोरियल में खुद का उपयोग करके दिखाया गया है
डाटासेट।
`# कॉपीराइट 2015 TensorFlow लेखक। सर्वाधिकार सुरक्षित।
अपाचे लाइसेंस, संस्करण 2.0 ("लाइसेंस") के तहत लाइसेंस प्राप्त; आप कर सकते हैं
लाइसेंस के अनुपालन के अलावा इस फ़ाइल का उपयोग न करें। आप प्राप्त कर सकते हैं
http://www.apache.org/licenses/LICENSE-2.0 पर लाइसेंस की प्रति जब तक
लागू कानून द्वारा आवश्यक या लिखित रूप में सहमत, सॉफ़्टवेयर वितरित
लाइसेंस के तहत वारंटी के बिना "जैसा है" के आधार पर वितरित किया जाता है
या किसी भी प्रकार की शर्तें, या तो व्यक्त या निहित। के लिए लाइसेंस देखें
के अंतर्गत अनुमतियों और सीमाओं को नियंत्रित करने वाली विशिष्ट भाषा

लाइसेंस। ============================================ ==========

"" "एक ध्यान तंत्र के साथ अनुक्रम-से-अनुक्रम मॉडल।" ""

भविष्य के आयात से निरपेक्ष_आयात
भविष्य के आयात विभाग से
भविष्य के आयात से print_function

यादृच्छिक आयात करें

np . के रूप में numpy आयात करें
छह से। आयात xrange # पाइलिंट: अक्षम = पुनर्परिभाषित-बिल्टिन
tf . के रूप में टेंसरफ़्लो आयात करें

आयात data_utils

वर्ग Seq2SeqModel (वस्तु):
"" "अनुक्रम-से-अनुक्रम मॉडल ध्यान के साथ और एकाधिक बाल्टी के लिए।

यह वर्ग एन्कोडर के रूप में एक बहु-परत आवर्तक तंत्रिका नेटवर्क को लागू करता है,
और एक ध्यान आधारित डिकोडर। यह वही है जो मॉडल में वर्णित है
यह पेपर: http://arxiv.org/abs/1412.7449 - कृपया वहां देखें
विवरण,
या पूर्ण मॉडल कार्यान्वयन के लिए seq2seq पुस्तकालय में।
यह वर्ग LSTM कोशिकाओं के अलावा GRU कोशिकाओं का उपयोग करने की भी अनुमति देता है, और
बड़े आउटपुट शब्दावली आकार को संभालने के लिए नमूना सॉफ्टमैक्स। एक सिंगल-लेयर
इस मॉडल का संस्करण, लेकिन द्वि-दिशात्मक एन्कोडर के साथ, में प्रस्तुत किया गया था
http://arxiv.org/abs/1409.0473
और नमूना सॉफ्टमैक्स निम्नलिखित पेपर की धारा 3 में वर्णित है।
http://arxiv.org/abs/1412.2007
"""

डीईएफ़ इनिट (स्वयं,
स्रोत_वोकैब_आकार,
लक्ष्य_वोकैब_आकार,
बाल्टी,
आकार,
num_layers,
max_gradient_norm,
बैच का आकार,
सीखने की दर,
Learning_rate_decay_factor,
use_lstm=गलत,
num_samples=512,
आगे_केवल=गलत,
dtype=tf.float32):
"" "मॉडल बनाएं।

आर्ग्स:
source_vocab_size: स्रोत शब्दावली का आकार।
target_vocab_size: लक्ष्य शब्दावली का आकार।
बाल्टी: जोड़े की एक सूची (I, O), जहां मैं अधिकतम इनपुट लंबाई निर्दिष्ट करता हूं
उस बाल्टी में संसाधित किया जाएगा, और ओ अधिकतम आउटपुट निर्दिष्ट करता है
लंबाई। प्रशिक्षण उदाहरण जिनमें I या आउटपुट से अधिक इनपुट हैं
O से अधिक लंबे समय को अगली बाल्टी में धकेला जाएगा और तदनुसार गद्देदार किया जाएगा।
हम मानते हैं कि सूची को क्रमबद्ध किया गया है, उदाहरण के लिए, [(2, 4), (8, 16)]।
आकार: मॉडल की प्रत्येक परत में इकाइयों की संख्या।
num_layers: मॉडल में परतों की संख्या।
max_gradient_norm: ग्रेडिएंट्स को इस मानदंड को अधिकतम करने के लिए क्लिप किया जाएगा।
बैच_साइज़: प्रशिक्षण के दौरान उपयोग किए जाने वाले बैचों का आकार;
मॉडल निर्माण बैच_साइज़ से स्वतंत्र है, इसलिए यह हो सकता है
आरंभीकरण के बाद बदल दिया गया है यदि यह सुविधाजनक है, उदाहरण के लिए, डिकोडिंग के लिए।
Learning_rate: सीखने की दर शुरू करने के लिए।
Learning_rate_decay_factor: जरूरत पड़ने पर सीखने की दर को इतना कम करना।
use_lstm: यदि सही है, तो हम GRU सेल के बजाय LSTM सेल का उपयोग करते हैं।
num_samples: नमूना सॉफ्टमैक्स के लिए नमूनों की संख्या।
Forward_only: यदि सेट किया जाता है, तो हम मॉडल में बैकवर्ड पास का निर्माण नहीं करते हैं।
dtype: आंतरिक चर को संग्रहीत करने के लिए उपयोग किया जाने वाला डेटा प्रकार।
"""
self.source_vocab_size = source_vocab_size
self.target_vocab_size = target_vocab_size
स्वयं बाल्टी = बाल्टी
स्वयं.बैच_साइज़ = बैच_साइज़
self.learning_rate = tf.Variable(
फ्लोट (लर्निंग_रेट), ट्रेन करने योग्य = गलत, 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_loss_function = कोई नहीं

नमूना सॉफ्टमैक्स केवल तभी समझ में आता है जब हम शब्दावली के आकार से कम का नमूना लेते हैं।

अगर num_samples > 0 और num_samples < self.target_vocab_size:
w_t = tf.get_variable("proj_w", [self.target_vocab_size, size], dtype=dtype)
w = tf. स्थानान्तरण (w_t)
b = tf.get_variable("proj_b", [self.target_vocab_size], dtype=dtype)
आउटपुट_प्रोजेक्शन = (डब्ल्यू, बी)

def नमूना_लॉस (लेबल, इनपुट):
लेबल = tf.reshape (लेबल, [-1, 1])
# हमें 32 बिट फ्लोट का उपयोग करके नमूना_सॉफ्टमैक्स_लॉस की गणना करने की आवश्यकता है
#संख्यात्मक अस्थिरता से बचें।
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),
डीटाइप)
softmax_loss_function = sampled_loss

हमारे आरएनएन के लिए आंतरिक बहु-परत सेल बनाएं।

डीईएफ़ सिंगल_सेल ():
वापसी tf.nn.rnn_cell.GRUCसेल (आकार)
अगर use_lstm:
डीईएफ़ सिंगल_सेल ():
वापसी tf.nn.rnn_cell.BasicLSTMCell(आकार)
सेल = सिंगल_सेल ()
अगर num_layers> 1:
सेल = tf.nn.rnn_cell.MultiRNNCell([single_cell() for _ in range(num_layers)])

Seq2seq फ़ंक्शन: हम इनपुट और ध्यान के लिए एम्बेडिंग का उपयोग करते हैं।

def seq2seq_f (encoder_inputs, decoder_inputs, do_decode):
वापसी tf.contrib.legacy_seq2seq.embedding_attention_seq2seq(
एन्कोडर_इनपुट,
डिकोडर_इनपुट्स,
कक्ष,
num_encoder_symbols=source_vocab_size,
num_decoder_symbols=target_vocab_size,
एम्बेडिंग_साइज़ = आकार,
आउटपुट_प्रोजेक्शन = आउटपुट_प्रोजेक्शन,
Feed_previous=do_decode,
डीटाइप = डीटाइप)

इनपुट के लिए फ़ीड।

self.encoder_inputs = []
self.decoder_inputs = []
स्व.लक्ष्य_वजन = []
for i in xrange(buckets[-1][0]): # लास्ट बकेट सबसे बड़ा है।
self.encoder_inputs.append(tf.placeholder(tf.int32, आकार=[कोई नहीं],
name="encoder{0}".format(i)))
मैं xrange में (बाल्टी [-1] [1] + 1) के लिए:
self.decoder_inputs.append(tf.placeholder(tf.int32, आकार = [कोई नहीं],
नाम = "डिकोडर{0}"। प्रारूप (i)))
self.target_weights.append(tf.placeholder(dtype, आकार=[कोई नहीं],
नाम = "वजन{0}"। प्रारूप (i)))

हमारे लक्ष्य डिकोडर इनपुट हैं जिन्हें एक द्वारा स्थानांतरित किया गया है।

लक्ष्य = [self.decoder_inputs[i + 1]
मैं के लिए xrange में (लेन (self.decoder_inputs) - 1)]

प्रशिक्षण परिणाम और हानियाँ।

अगर आगे_केवल:
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),
सॉफ्टमैक्स_लॉस_फंक्शन = सॉफ्टमैक्स_लॉस_फंक्शन)
# यदि हम आउटपुट प्रोजेक्शन का उपयोग करते हैं, तो हमें आउटपुट को डिकोडिंग के लिए प्रोजेक्ट करना होगा।
अगर output_projection कोई नहीं है:
b के लिए xrange (लेन (बाल्टी)) में:
स्वयं आउटपुट [बी] = [
tf.matmul (आउटपुट, आउटपुट_प्रोजेक्शन [0]) + आउटपुट_प्रोजेक्शन [1]
स्वयं आउटपुट में आउटपुट के लिए [बी]
]
अन्यथा:
self.outputs, self.losses = tf.contrib.legacy_seq2seq.model_with_buckets(
self.encoder_inputs, self.decoder_inputs, लक्ष्य,
self.target_weights, बकेट,
लैम्ब्डा एक्स, वाई: seq2seq_f (एक्स, वाई, गलत),
सॉफ्टमैक्स_लॉस_फंक्शन = सॉफ्टमैक्स_लॉस_फंक्शन)

मॉडल के प्रशिक्षण के लिए ग्रेडिएंट और एसजीडी अपडेट ऑपरेशन।

पैराम्स = tf.trainable_variables ()
अगर अग्रेषित नहीं है केवल:
स्व.ग्रेडिएंट_नॉर्म्स = []
स्वयं अपडेट = []
ऑप्ट = tf.train.GradientDescentOptimizer(self.learning_rate)
b के लिए xrange (लेन (बाल्टी)) में:
ग्रेडिएंट्स = tf.gradients(self.losses[b], params)
क्लिप्ड_ग्रेडिएंट्स, मानदंड = tf.clip_by_global_norm (ग्रेडिएंट्स,
max_gradient_norm)
self.gradient_norms.append (मानदंड)
self.updates.append(opt.apply_gradients(
zip(clipped_gradients, params), global_step=self.global_step))

सेल्फ.सेवर = tf.train.Saver (tf.global_variables ())

डीईएफ़ चरण (स्वयं, सत्र, एन्कोडर_इनपुट्स, डिकोडर_इनपुट्स, टारगेट_वेट्स,
बकेट_आईडी, फॉरवर्ड_ओनली):
"""दिए गए इनपुट को फीड करने वाले मॉडल का एक चरण चलाएँ।

आर्ग्स:
सत्र: उपयोग करने के लिए टेंसरफ़्लो सत्र।
encoder_inputs: एन्कोडर इनपुट के रूप में फीड करने के लिए numpy int वैक्टर की सूची।
decoder_inputs: डिकोडर इनपुट के रूप में फीड करने के लिए numpy int वैक्टर की सूची।
target_weights: लक्ष्य वज़न के रूप में फ़ीड करने के लिए सुन्न फ्लोट वैक्टर की सूची।
बाल्टी_आईडी: मॉडल की किस बकेट का उपयोग करना है।
Forward_only: बैकवर्ड स्टेप करना है या सिर्फ फॉरवर्ड करना है।

रिटर्न:
ग्रेडिएंट मानदंड से युक्त एक ट्रिपल (या कोई नहीं अगर हम पिछड़ा नहीं करते हैं),
औसत परेशानी, और आउटपुट।

उठाता है:
ValueError: अगर encoder_inputs की लंबाई, decoder_inputs, या
लक्ष्य_वेट निर्दिष्ट बकेट_आईडी के लिए बकेट आकार से असहमत हैं।
"""

जांचें कि क्या आकार मेल खाते हैं।

encoder_size, decoder_size = self.buckets[bucket_id]
अगर लेन (एनकोडर_इनपुट्स) != एनकोडर_साइज़:
ValueError बढ़ाएँ ("एनकोडर की लंबाई बाल्टी में एक के बराबर होनी चाहिए,"
"%d!=%d." % (लेन (एनकोडर_इनपुट), एन्कोडर_साइज़))
अगर लेन (डिकोडर_इनपुट्स)! = डिकोडर_साइज़:
ValueError बढ़ाएँ ("डिकोडर की लंबाई बाल्टी में एक के बराबर होनी चाहिए,"
"%d!=%d." % (लेन (डिकोडर_इनपुट), डिकोडर_साइज़))
अगर लेन (target_weights) != decoder_size:
ValueError बढ़ाएँ ("वजन की लंबाई बाल्टी में एक के बराबर होनी चाहिए,"
"%d!=%d." % (लेन(target_weights), decoder_size))

इनपुट फ़ीड: एन्कोडर इनपुट, डिकोडर इनपुट, टारगेट_वेट, जैसा कि दिया गया है।

इनपुट_फीड = {}
l के लिए xrange(encoder_size) में:
input_feed[self.encoder_inputs[l].name] = encoder_inputs[l]
l के लिए xrange (डिकोडर_साइज़) में:
input_feed[self.decoder_inputs[l].name] = decoder_inputs[l]
input_feed[self.target_weights[l].name] = target_weights[l]

चूंकि हमारे लक्ष्य डिकोडर इनपुट हैं जो एक द्वारा स्थानांतरित किए गए हैं, हमें एक और की आवश्यकता है।

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

आउटपुट फीड: इस पर निर्भर करता है कि हम बैकवर्ड स्टेप करते हैं या नहीं।

अगर अग्रेषित नहीं है केवल:
output_feed = [self.updates[bucket_id], # Update Op जो SGD करता है।
self.gradient_norms[bucket_id], # ग्रेडिएंट मानदंड।
self.losses[bucket_id]] # इस बैच के लिए नुकसान।
अन्यथा:
output_feed = [self.losses[bucket_id]] # इस बैच के लिए नुकसान।
l के लिए xrange(decoder_size) में: # आउटपुट logits.
output_feed.append(self.outputs[bucket_id][l])

आउटपुट = सत्र। रन (आउटपुट_फीड, इनपुट_फीड)
अगर अग्रेषित नहीं है केवल:
रिटर्न आउटपुट [1], आउटपुट [2], कोई नहीं # ग्रेडिएंट मानदंड, हानि, कोई आउटपुट नहीं।
अन्यथा:
कोई नहीं, आउटपुट [0], आउटपुट [1:] # कोई ग्रेडिएंट मानदंड, हानि, आउटपुट नहीं।

def get_batch (स्वयं, डेटा, बाल्टी_आईडी):
"""निर्दिष्ट बकेट से डेटा का एक यादृच्छिक बैच प्राप्त करें, चरण के लिए तैयार करें।

स्टेप (..) में डेटा फीड करने के लिए यह बैच-मेजर वैक्टर की एक सूची होनी चाहिए, जबकि
यहां डेटा में एकल लंबाई-प्रमुख मामले हैं। तो इसका मुख्य तर्क
कार्य डेटा मामलों को खिलाने के लिए उचित प्रारूप में पुन: अनुक्रमित करना है।

आर्ग्स:
डेटा: आकार len(self.buckets) का एक टपल जिसमें प्रत्येक तत्व होता है
इनपुट और आउटपुट डेटा के जोड़े की सूची जो हम एक बैच बनाने के लिए उपयोग करते हैं।
बाल्टी_आईडी: पूर्णांक, किस बाल्टी के लिए बैच प्राप्त करना है।

रिटर्न:
ट्रिपल (एनकोडर_इनपुट्स, डिकोडर_इनपुट्स, टारगेट_वेट्स) के लिए
निर्मित बैच जिसमें बाद में चरण (...) को कॉल करने के लिए उचित प्रारूप है।
"""
encoder_size, decoder_size = self.buckets[bucket_id]
encoder_inputs, decoder_inputs = [], []

डेटा से एन्कोडर और डिकोडर इनपुट का एक यादृच्छिक बैच प्राप्त करें,

यदि आवश्यक हो तो उन्हें पैड करें, एन्कोडर इनपुट को उल्टा करें और डिकोडर में GO जोड़ें।

xrange में _ के लिए (self.batch_size):
encoder_input, decoder_input = random.choice(data[bucket_id])

# एनकोडर इनपुट को गद्देदार किया जाता है और फिर उलट दिया जाता है।
encoder_pad = [data_utils.PAD_ID] * (encoder_size - len(encoder_input))
encoder_inputs.append (सूची (उलट (एनकोडर_इनपुट + एन्कोडर_पैड)))

# डिकोडर इनपुट को एक अतिरिक्त "GO" प्रतीक मिलता है, और फिर गद्देदार होते हैं।
डिकोडर_पैड_साइज़ = डिकोडर_साइज़ - लेन (डिकोडर_इनपुट) - 1
decoder_inputs.append([data_utils.GO_ID] + decoder_input +
[data_utils.PAD_ID] * decoder_pad_size)

अब हम ऊपर चुने गए डेटा से बैच-मेजर वैक्टर बनाते हैं।

बैच_एनकोडर_इनपुट्स, बैच_डिकोडर_इनपुट्स, बैच_वेट्स = [], [], []

बैच एन्कोडर इनपुट केवल एन्कोडर_इनपुट को फिर से अनुक्रमित किया जाता है।

xrange में length_idx के लिए (एनकोडर_साइज़):
बैच_एनकोडर_इनपुट्स। संलग्न करें (
np.array([encoder_inputs[batch_idx][length_idx]
बैच_आईडीएक्स के लिए xrange(self.batch_size)], dtype=np.int32))

बैच डिकोडर इनपुट पुन: अनुक्रमित डिकोडर_इनपुट हैं, हम वज़न बनाते हैं।

xrange में length_idx के लिए (डिकोडर_साइज़):
बैच_डिकोडर_इनपुट्स। संलग्न करें (
np.array([decoder_inputs[batch_idx][length_idx]
बैच_आईडीएक्स के लिए xrange(self.batch_size)], dtype=np.int32))

# पैडिंग करने वाले लक्ष्यों के लिए target_weights 0 होने के लिए बनाएं।
बैच_वेट = np.ones (self.batch_size, dtype=np.float32)
बैच_आईडीएक्स के लिए xrange (self.batch_size) में:
# हम वजन को 0 पर सेट करते हैं यदि संबंधित लक्ष्य PAD प्रतीक है।
# संबंधित लक्ष्य डिकोडर_इनपुट है जिसे 1 आगे स्थानांतरित किया गया है।
अगर लंबाई_आईडीएक्स <डिकोडर_साइज -1:
लक्ष्य = डिकोडर_इनपुट्स [बैच_आईडीएक्स] [लंबाई_आईडीएक्स + 1]
अगर length_idx == decoder_size - 1 या लक्ष्य == data_utils.PAD_ID:
बैच_वेट [बैच_आईडीएक्स] = 0.0
बैच_वेट्स.एपेंड (बैच_वेट)
वापसी बैच_एनकोडर_इनपुट, बैच_डिकोडर_इनपुट, बैच_वेट `

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-312679587 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/ABtim0l5UMHHtbL1sz7meXserV8NVS7cks5sKQzXgaJpZM4MWl4f
.

ठीक! हालांकि धन्यवाद! :)

@ebrevdo क्या कोई अपडेट है जब नई एपीआई का उपयोग कर seq2seq का नया ट्यूटोरियल सामने आएगा?
शुक्रिया। अद्भुत कार्य!।

हाँ नए ट्यूटोरियल की प्रतीक्षा कर रहा है ... यह जानना बहुत अच्छा होगा कि क्या इसे जल्द ही जारी करने की योजना है .. @ebrevdo

कर्नेल परीक्षणों में कोड लेने और विरासत seq2seq के साथ बीम खोज को फिर से निकालने की कोशिश की, लेकिन यह चुनौतीपूर्ण था ...

हम इस आने वाले सप्ताह की उम्मीद कर रहे हैं!

3 जुलाई 2017 को सुबह 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
.

हाय दोस्तों,

इस मुद्दे के लिए कोई भी अपडेट, मैं मैक ओएस एक्स के लिए टेंसरफ्लो 1.1-जीपीयू पर समान अनुभव कर रहा हूं

@tshi1983
मुझे उबंटू के लिए टेंसरफ्लो 1.1-जीपीयू के साथ एक ही समस्या मिली।
मैं टीएफ 1.2 में अपग्रेड करता हूं। यह अभी भी काम नहीं करता है।
फिर मैं फ़ाइल में एम्बेडिंग_अटेंशन_seq2seq फ़ंक्शन को बदलता हूं
tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py
जैसा कि @fabiofumarola ने ऊपर सुझाया है।
अब इसकी ट्रेनिंग शुरू हो गई है। मैंने अभी तक डिकोडिंग का परीक्षण नहीं किया है।

सेल परिभाषा पर कोड को 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 translation.py --data_dir data/ --train_dir checkpoint/ --size=256 --num_layers=2 --steps_per_checkpoint=50" काम कर सकता है।

@huxuanlai यह काम करता है! कम से कम यह अभी प्रशिक्षण ले रहा है, thx!

@huxuanlai मेरे लिए भी काम करता है।

मुझे वही प्राप्त हो रहा है AttributeError: 'NoneType' object has no attribute 'update' लेकिन साथ में tf.contrib.legacy_seq2seq.model_with_buckets । मैं ubuntu 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'

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

यह अभी भी तय नहीं है, इस धागे और स्टैक ओवरफ्लो में उल्लिखित सभी संभावित समाधानों की कोशिश की, यह टेंसरफ्लो 1.3 या 1.2 या 1.1 के साथ काम नहीं करता है

मुझे इस त्रुटि का सामना करना पड़ रहा है:
TypeError: embedding_attention_seq2seq() missing 1 required positional argument: 'dec_cell'

त्रुटि इस फ़ंक्शन को seq2seq_model.py में इंगित करती है जो seq2seq_model.py में पंक्ति 142 है:

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)

जो कोई भी इस त्रुटि के साथ आया और इसे हल करने में कामयाब रहा, कृपया इस मुद्दे को ठीक करने में मेरी सहायता करें।

ValueError: आरएनएनसेल का पुन: उपयोग करने का प्रयासइसके पहले उपयोग की तुलना में एक अलग परिवर्तनीय दायरे के साथ। सेल का पहला प्रयोग स्कोप '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)])। यदि इससे पहले आप एक ही सेल इंस्टेंस का उपयोग एक द्विदिश आरएनएन के फॉरवर्ड और रिवर्स सेल दोनों के रूप में कर रहे थे, तो बस दो इंस्टेंस बनाएं (एक फॉरवर्ड के लिए, एक रिवर्स के लिए)। मई 2017 में, हम मौजूदा संग्रहीत वज़न का उपयोग करने के लिए इस सेल के व्यवहार को बदलना शुरू कर देंगे, यदि कोई हो, जब इसे स्कोप = कोई नहीं कहा जाता है (जिससे मूक मॉडल गिरावट हो सकती है, इसलिए यह त्रुटि तब तक बनी रहेगी।)

मूल कोड:
tensorflow.contrib से आयात rnn
इनपुट्स = tf.प्लेसहोल्डर (dtype=tf.int32, आकार=[कोई नहीं, कोई नहीं], नाम = "इनपुट्स")
Keep_prob = tf.प्लेसहोल्डर (dtype=tf.float32, name="keep_prob")
सेल = rnn.GRUCसेल(10)
सेल = rnn.DropoutWrapper (सेल = सेल, input_keep_prob=keep_prob)
सेल = rnn.MultiRNNCell([श्रेणी में _ के लिए सेल(5)], State_is_tuple=True)

बाहरी, राज्य = tf.nn.dynamic_rnn (सेल = सेल, इनपुट = लुक_अप, dtype = tf.float32)
उपाय:
इनपुट्स = tf.प्लेसहोल्डर (dtype=tf.int32, आकार=[कोई नहीं, कोई नहीं], नाम = "इनपुट्स")
Keep_prob = tf.प्लेसहोल्डर (dtype=tf.float32, name="keep_prob")
सेल = rnn.MultiRNNCell([rnn.DropoutWrapper(rnn.GRUCell(10), input_keep_prob=keep_prob) _इन रेंज(5)] के लिए, State_is_tuple=True)

क्या आपके पास tf नाइटलीज़ के साथ यह समस्या है?

1 अक्टूबर, 2017 को सुबह 8:34 बजे, "बाओहुआ झोउ" नोटिफिकेशन @github.com ने लिखा:

आईओएस के साथ सीपीयू पर टेंसरफ्लो 1.1 का उपयोग करते समय मेरे पास एक ही समस्या है।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/tensorflow/tensorflow/issues/8191#issuecomment-333384725 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/ABtimwOv7vf5vvFXBllbZryjCFwmJcU6ks5sn7DxgaJpZM4MWl4f
.

विशेषता त्रुटि: 'कोई नहीं' ऑब्जेक्ट में कोई विशेषता नहीं है 'अपडेट'

टीएफ = 1.3 . में

ValueError: आरएनएनसेल का पुन: उपयोग करने का प्रयासइसके पहले उपयोग की तुलना में एक अलग परिवर्तनीय दायरे के साथ। सेल का पहला प्रयोग '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)])। यदि इससे पहले आप एक ही सेल इंस्टेंस का उपयोग एक द्विदिश आरएनएन के फॉरवर्ड और रिवर्स सेल दोनों के रूप में कर रहे थे, तो बस दो इंस्टेंस बनाएं (एक फॉरवर्ड के लिए, एक रिवर्स के लिए)। मई 2017 में, हम मौजूदा संग्रहीत वज़न का उपयोग करने के लिए इस सेल के व्यवहार को बदलना शुरू कर देंगे, यदि कोई हो, जब इसे स्कोप = कोई नहीं कहा जाता है (जिससे मूक मॉडल गिरावट हो सकती है, इसलिए यह त्रुटि तब तक बनी रहेगी।)

बिना किसी गतिविधि के 14 दिन हो गए हैं और awaiting tensorflower लेबल असाइन किया गया था। कृपया तदनुसार लेबल और/या स्थिति अपडेट करें।

TensorFlower की प्रतीक्षा कर रहा है: बिना किसी गतिविधि के 14 दिन हो गए हैं और awaiting tensorflower लेबल असाइन किया गया था। कृपया तदनुसार लेबल और/या स्थिति अपडेट करें।

समाधान TF के नए संस्करण में जाना है। यह धागा अपने मूल मुद्दे से काफी अलग हो गया है। समापन।

यदि आप तत्काल समाधान चाहते हैं तो आप जो कोशिश कर सकते हैं उसे आजमा सकते हैं:

pip install tensorflow==1.0
मुद्दा टेनॉरफ़्लो 1.1 संस्करण के साथ है, इसने मेरे लिए काम किया।