ValueError                                Traceback (most recent call last)
<ipython-input-44-2ec1176683f0> in <module>
----> 1 translate(u'Estoy trabajando.')

<ipython-input-43-4364cc5c7981> in translate(input_sentence)
     49 
     50 def translate(input_sentence):
---> 51     results, input_sentence, attention_matrix = evaluate(input_sentence)
     52 
     53     print("Input: %s" % (input_sentence))

<ipython-input-43-4364cc5c7981> in evaluate(input_sentence)
     20     decoding_input = tf.expand_dims([out_tokenizer.word_index['<start>']], 0)
     21     for t in range(max_length_output):
---> 22         predictions. decoding_hidden, attention_weights = decoder(decoding_input, decoding_hidden, encoding_outputs)
     23         attention_weights = tf.reshape(attention_weights, (-1,))
     24         attention_matrix[t] = attention_weights.numpy()

ValueError: too many values to unpack (expected 2)

def evaluate(input_sentence):
    attention_matrix = np.zeros((max_length_output, max_length_input)) # 定义attention_matrix 保存权重。shape:()
    input_sentence = preprocess_sentence(input_sentence) # 输入的句子进行预处理。就是分割标点符号/

    inputs = [input_tokenizer.word_index[token] for token in input_sentence.split(' ')] # text--->id 把句子转换成id
    inputs = keras.preprocessing.sequence.pad_sequences([inputs], maxlen = max_length_input, padding= 'post') # 把转换成id的向量，进行padding
    inputs = tf.convert_to_tensor(inputs) #把向量转换为tensor

    results = '' # 定义str, 保存translate的结果

#     encoding_hidden = encoder.initialize_hidden_state()

    encoding_hidden = tf.zeros((1, units)) #初始化encoding_hidden层

    encoding_outputs, encoding_hidden = encoder(inputs, encoding_hidden) # 这一步得到的encoding_hidden就是decoding_hidden 的第一个值
    decoding_hidden = encoding_hidden


    decoding_input = tf.expand_dims([out_tokenizer.word_index['<start>']], 0) # 找到开始的第一个输入的id
    for t in range(max_length_output):
        predictions, decoding_hidden, attention_weights = decoder(decoding_input, decoding_hidden, encoding_outputs)
        attention_weights = tf.reshape(attention_weights, (-1,))
        attention_matrix[t] = attention_weights.numpy()

        predicted_id = tf.argmax(predictions[0]).numpy()

        results += out_tokenizer.index_word[predicted_id] + ' '

        if out_tokenizer.index_word[predicted_id] == '<end>':
            return results, input_sentence, attention_matrix

        decoding_input = tf.expand_dims([predicted_id], 0)
    return results, input_sentence, attention_matrix

def plot_attention(attention_matrix, input_sentence, predicted_sentence):
    fig = plt.figure(figsize=(10,10))
    ax = fig.add_subplot(1, 1, 1)

    ax.matshow(attention_matrix, cmap='viridis')

    font_dict = {'fontsize': 14}

    ax.set_xticklabels([''] + input_sentence,
                              fontdict = font_dict, rotation = 90)
    ax.sey_yticklables([''] + predicted_sentence,
                              fontdict = font_dict,)
    plt.show()

def translate(input_sentence):
    results, input_sentence, attention_matrix = evaluate(input_sentence)

    print("Input: %s" % (input_sentence))
    print("Predicted translation: %s" % (results))

    attention_matrix = attention_matrix[:len(results.split(' ')),
                                                       :len(input_sentence.split(' '))]
    plot_attention(attention_matrix, input_sentence.split(' '), results.split(' '))

class Encoder (keras.Model):
    def __init__(self, vocab_size, embedding_units, encoding_units, batch_size):
        super(Encoder, self).__init__()
        self.batch_size = batch_size
        self.encoding_units = encoding_units
        self.embedding = keras.layers.Embedding(vocab_size,embedding_units)
        self.gru = keras.layers.GRU(self.encoding_units,return_sequences=True,return_state=True, 
                                recurrent_initializer='glorot_uniform')
    def call(self, x, hidden):
        x = self.embedding(x)
        output, state = self.gru(x, initial_state=hidden) ## 这里的self.gru() 传递的两个参数是什么意思呢？在构造函数里面并没有使用这两个参数， 但是在api里 可以找到这个参数。
        return output, state
    def initialize_hidden_state(self):
        return tf.zeros((self.batch_size,self.encoding_units))

encode = Encoder(input_vocab_size, embedding_units, units, batch_size)

sample_hidden = encoder.initialize_hidden_state()

sample_output, sample_hidden = encoder(x, sample_hidden)


## 输入模型的数据特征
[in]
for array in (input_train, input_eval, output_train, output_eval):
    print( type(array), array.shape)
[out]
    <class 'numpy.ndarray'> (24, 9)
    <class 'numpy.ndarray'> (7, 9)
    <class 'numpy.ndarray'> (24, 14)
    <class 'numpy.ndarray'> (7, 14)

可以这样理解，对于 input_train 来说，有24个样本，每个样本有9个特征。对于这个9。就是每个句子的单词数，但是有的句子单词不够9个，这在预处理数据的时候进行了padding操作。样本数是24，在train_test_split(test_size=0.2)分配的数据量。

[In]
a = [(1,2),(3,4),(5,6)]
print(type(a))
print(len(a))
[out]
<class 'list'>
3
[In]
def a(a):
    return(print(a))
def b(a):
    return(print(a))

a(c),b(d) for c,d in a

def generate_x_y_data_v1(isTrain, batch_size):
#     """
# 练习数据1。
#      返回：元组（X，Y）
#          X是从0.0 * pi到1.5 * pi的正弦和余弦
#          Y是从1.5 * pi到3.0 * pi的正弦和余弦
#      因此，Y跟随X.还有一个通常应用于X和Y的随机偏移。

#      返回的数组具有以下形状：（seq_length，batch_size，output_dim）
#         因此：（10，batch_size，2）
#      对于本练习，让我们忽略“isTrain”
#      论证和测试相同的数据。
#     """
seq_length = 3
batch_size = 3

batch_x = []
batch_y = []
for _ in range(batch_size):
    rand = random.random() * 2 * math.pi

    sig1 = np.sin(np.linspace(0.0 * math.pi + rand,
                              3.0 * math.pi + rand, seq_length * 2))
    print(_)
    print(sig1)
    sig2 = np.cos(np.linspace(0.0 * math.pi + rand,
                              3.0 * math.pi + rand, seq_length * 2))
    x1 = sig1[:seq_length]
    y1 = sig1[seq_length:]
    x2 = sig2[:seq_length]
    y2 = sig2[seq_length:]

    x_ = np.array([x1, x2])
    y_ = np.array([y1, y2])
    x_, y_ = x_.T, y_.T

    batch_x.append(x_)
    batch_y.append(y_)

batch_x = np.array(batch_x)
batch_y = np.array(batch_y)
# shape: (batch_size, seq_length, output_dim)

batch_x = np.array(batch_x).transpose((1, 0, 2))
batch_y = np.array(batch_y).transpose((1, 0, 2))
# shape: (seq_length, batch_size, output_dim)

    return batch_x, batch_y