Seq2Seq числовое считывание кода

# - * - Coding: UTF-8 - * - 
Импорт tensorflow AS TF
 Import NumPy AS NP
 Import Helper 

# ########################### ########################### определение модель 
пэд = 0 
ЭОС =. 1
 # УНК = 2 
# ОХ =. 3 

vocab_size = 10 # словарь общих 10 цифровой 
input_embedding_size = 20 # размеры вектора слов, т.е. каждое слово представлено множеством цифровых 

encoder_hidden_units = 20 
decoder_hidden_units = encoder_hidden_units 
encoder_inputs = tf.placeholder (Форма = (None, None), DTYPE = tf.int32, имя = ' encoder_inputs' ) 
Decoder_targets = tf.placeholder (форма = (None, None), DTYPE = tf.int32, имя = ' decoder_targets ' ) 
decoder_inputs = tf.placeholder (форма = (None, None), DTYPE = tf.int32, имя = ' decoder_inputs ' ) 

# ############################################# ######### вложения 
вложения = tf.Variable (tf.truncated_normal ([vocab_size, input_embedding_size], среднее значение = 0,0, StdDev = 0,1 ), 
                         DTYPE = tf.float32) # [10,20] 
encoder_inputs_embedded = тс .nn.embedding_lookup (вложения, encoder_inputs) 
decoder_inputs_embedded =tf.nn.embedding_lookup (вложения, decoder_inputs) 

# Печать (encoder_inputs_embedded) # Shape = (?,?, 20) 


# ######################## ############################## кодирующие 
encoder_cell = tf.contrib.rnn.BasicLSTMCell (encoder_hidden_units) 
lstm_layers = 4. 
Ячейка = TF. contrib.rnn.MultiRNNCell ([encoder_cell] * lstm_layers) 
encoder_outputs, encoder_final_state = tf.nn.dynamic_rnn (ячейка, encoder_inputs_embedded, 
                                                         DTYPE = tf.float32, time_major = True)
 дель encoder_outputs # удален encoder_outputs, потому что в этом случае мы не беспокоит то , что нам нужно , это последняя encoder_final_state
# Печать (encoder_final_state) 
# только ввести , если не существует никакого механизма для введения внимания, encoder_final_state является декодер, и 
# , чтобы решить decoder_targets с ним как входной параметр init_state декодера. 
# ################################################# ##### декодирования 

decoder_cell = tf.contrib.rnn.BasicLSTMCell (decoder_hidden_units) 
декодер = tf.contrib.rnn.MultiRNNCell ([decoder_cell] * lstm_layers) 
decoder_outputs, decoder_final_state = tf.nn.dynamic_rnn ( 
    декодер, decoder_inputs_embedded, 
    initial_state = encoder_final_state, 
    DTYPE = tf.float32, time_major = True, область = " plain_decoder ", 
) 
Decoder_logits = tf.contrib.layers.fully_connected (decoder_outputs, vocab_size, activation_fn = Отсутствует, 
                                              weights_initializer = tf.truncated_normal_initializer (StdDev = 0,1 ), 
                                              biases_initializer = tf.zeros_initializer ())
 # печати (decoder_logits) # форма = (?, ?, 10) 
decoder_prediction = tf.argmax (decoder_logits, 2) # 2表明的是哪个维度Опубликовать на 上求Argmax 
# печати (decoder_prediction) # форма = (?,?) 
stepwise_cross_entropy = tf.nn.softmax_cross_entropy_with_logits ( 
    меткиtf.one_hot = (decoder_targets, глубина = vocab_size, DTYPE = tf.float32), 
    логит = decoder_logits, 
) 

Потеря = tf.reduce_mean (stepwise_cross_entropy) 
train_op = tf.train.AdamOptimizer (). Минимизация (потери) 

# #### ################################################## обучение моделирования 
# мы для простоты, она производит случайную последовательность входной и выходной сигнал декодера исходной модели , как 

в batch_size = 100 

серий = helper.random_sequences (= length_from. 3, length_to =. 8 , 
                                   vocab_lower = 2, 10 = vocab_upper , 
                                   в batch_size = в batch_size )

Печать ( ' руководитель Загрузку: ' )
 для SEQ в Next (партий) [10 ]:
     Печать (SEQ) 
    
    
DEF next_feed (): 
    ПАРТИЯ = Следующий (Порции) # на 100 случайным образом генерирует одномерный массив, объединены двумерный массив 
    # печати ( 'ПАРТИЯ __________', BATCH) 
    encoder_inputs_ _ = helper.batch (ПАРТИЯ)
     # печати ( '_ encoder_inputs', encoder_inputs_) 
    decoder_targets_ _ = helper.batch ( 
        [(последовательность) + [ЭОС] для последовательности в сЕРИЙНОГО] 
    ) 
    #печать ( 'decoder_targets _', decoder_targets_) 
    decoder_inputs_ _ = helper.batch ( 
        [[EOS] + (последовательность) для последовательности в партии] 
    ) 
    # печать ( 'decoder_inputs _', decoder_inputs_) 
    возвращение { 
        encoder_inputs: encoder_inputs_, 
        decoder_inputs: decoder_inputs_, 
        decoder_targets : decoder_targets_, 
    } 
    
loss_track = [] 

max_batches = 10001 
batches_in_epoch = 1000 

с tf.Session () в качестве Sess: 
    sess.run (tf.global_variables_initializer ()) 
    попробовать :
         дляпартия в диапазоне (max_batches): # 10001 
            FD = next_feed () 
            _ л = sess.run ([train_op, потеря], FD) 
            loss_track.append (л) , 

            если партия == 0 или партии% batches_in_epoch == 0:
                 печать ( ' партия {} ' .format (партия))
                 печати ( '   minibatch потери: {} ' .format (sess.run (потеря, FD))) 
                predict_ = sess.run (decoder_prediction, FD)
                 для I, (вх, ПРЕД) вПеречислим (почтовый индекс (FD [encoder_inputs] .T, predict_.T)):
                     печать ( '   образец {}: ' .format (г + 1 ))
                     для печати ( '     ввода> {} ' .format (вх))
                     печати ( '     предсказывал> {} ' .format (пред))
                     если я> = 2 :
                         перерыв 
                печати ()
     , за исключением KeyboardInterrupt:
         печать ( ' тренировка прервана » )

 

Выше код берется из  https://github.com/zhuanxuhit/nd101/blob/master/1.Intro_to_Deep_Learning/11.How_to_Make_a_Language_Translator/1-seq2seq.ipynb  интерпретации Seq2Seq.

Процесс обучения также требует  helper.py , могут быть скопированы , чтобы найти свой собственный путь из URL.

3001 от имени моего обучения не может добиться хороших результатов, поэтому он выбрал 10001 поколений.

При генерации входной последовательности, установив минимальную длину последовательности 3, максимальная длина 8. Каждая последовательность содержит некоторое число от 2 до 9. (Так как последний попадает необходимость добавить последовательность запуска представляет собой входной и выходной конец декодера или, где это требуется недостаточная длина заполнения для заполнения 0)

При чтении кода, структура входных данных в сети не очень понятно, следующий фрагмент кода

DEF next_feed (): 
    ПАРТИЯ = Следующий (Порции) # на 100 случайным образом генерирует одномерный массив, двумерный массив совмещен 
    # Печать ( 'BATCH __________', BATCH) 
    encoder_inputs_, _ = helper.batch (пакетная)
     # Печать ( 'encoder_inputs _', encoder_inputs_) 
    decoder_targets_, _ = helper.batch ( 
        [(последовательность) + [ЭОС] для последовательности в ПАРТИЯ] 
    ) 
    # Печать ( '_ decoder_targets', decoder_targets_) 
    decoder_inputs_, _ = helper.batch ( 
        [[ЭОС] + (Последовательность) для последовательности в BATCH] 
    ) 
    #печать ( '_' decoder_inputs, decoder_inputs_) 
    возвращение { 
        encoder_inputs: encoder_inputs_, 
        decoder_inputs: decoder_inputs_, 
        decoder_targets: decoder_targets_, 
    }

В выходной секции кода, представитель транспонированная матрица .T

batch_size = 100

 

Я читал много раз не понимаю, ввод и вывод данных, после того, как печать еще более размытым, так что я буду писать их, как небольшой пример для всех, чтобы интерпретировать.

Последний поезд из результатов

 

рекомендация

отwww.cnblogs.com/beautifulchenxi/p/11389300.html