The Rise of Smart Assistants on Facebook Messenger

    !pip install tensorflow==2.3.1

    
    
         
    代码解读

    ### 4.1.2 数据预处理
    ```python
    def load_dataset():
    """Load dataset and preprocess data."""
    task = "qa17_"
    
    train_path = f"{task}task{1}_train.txt"
    test_path = f"{task}task{1}_test.txt"
    
    X_train = []
    y_train = []
    X_test = []
    y_test = []
    
    with open(f"data/{train_path}") as file:
        for line in file:
            items = line.strip().split()
            if len(items) < 2:
                continue
    
            story = [int(i) for i in items[1:-1]]
            query = int(items[-1])
    
            X_train.append((story[:-1], query))
            y_train.append(story[-1])
    
    with open(f"data/{test_path}") as file:
        for line in file:
            items = line.strip().split()
            if len(items) < 2:
                continue
    
            story = [int(i) for i in items[1:-1]]
            query = int(items[-1])
    
            X_test.append((story[:-1], query))
            y_test.append(story[-1])
    
    return (X_train, y_train), (X_test, y_test)
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    from tensorflow import keras
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Dense, Embedding, LSTM, Dropout, Activation
    
    class Seq2SeqModel(object):
    def __init__(self, vocab_size, embed_dim, hidden_dim, dropout_rate=0.5):
        self.encoder_model = None
        self.decoder_model = None
    
        # Encoder model
        encoder_inputs = keras.Input(shape=(None,))
        x = Embedding(vocab_size, embed_dim)(encoder_inputs)
        x = LSTM(hidden_dim, return_sequences=False, name='encoder')(x)
        self.encoder_model = keras.Model(encoder_inputs, x, name='encoder')
    
        # Decoder model
        decoder_inputs = keras.Input(shape=(None,), name='decoder_inputs')
        initial_state = keras.Input(shape=(hidden_dim,), name='initial_state')
        x = Embedding(vocab_size, embed_dim)(decoder_inputs)
        x = LSTM(hidden_dim, return_sequences=True, 
                 name='decoder',
                 stateful=True,
                 initial_state=[initial_state]
                 )(x)
        outputs = TimeDistributed(Dense(vocab_size, activation='softmax'))(x)
        self.decoder_model = keras.Model([decoder_inputs, initial_state], outputs, name='decoder')
    
    def compile(self):
        optimizer = keras.optimizers.Adam(lr=0.01)
        loss ='sparse_categorical_crossentropy'
        self.decoder_model.compile(optimizer=optimizer, loss=loss)
    
    def fit(self, X_train, y_train, batch_size, epochs, validation_split):
        num_batches = len(X_train) // batch_size + 1
    
        history = {'loss': [], 'accuracy': []}
    
        for epoch in range(epochs):
            print('Epoch {}/{}'.format(epoch+1, epochs))
    
            # Train
            pbar = tqdm(range(num_batches), desc='Training')
            running_loss = 0.0
            total_acc = 0.0
            for i in pbar:
                input_batch = X_train[i*batch_size:(i+1)*batch_size][0]
                output_batch = [[y_train[k] for k in range(i*batch_size, (i+1)*batch_size)]]
    
                _, acc, loss = self._fit_batch(input_batch, output_batch)
    
                running_loss += loss * len(output_batch)
                total_acc += acc * len(output_batch)
                avg_loss = running_loss / ((i+1)*len(output_batch))
                avg_acc = total_acc / ((i+1)*len(output_batch))
    
                pbar.set_postfix({'Loss': '{:.4f}'.format(avg_loss)})
                pbar.set_postfix({'Accuracy': '{:.2%}'.format(avg_acc)})
    
            val_loss, val_acc = self.evaluate(*validation_split)
    
            print('\nValidation Loss:', val_loss)
            print('Validation Accuracy:', val_acc)
    
            # Store metrics
            history['loss'].append(avg_loss)
            history['accuracy'].append(avg_acc)
    
        return history
    
    def evaluate(self, X_test, y_test, batch_size=32):
        num_batches = len(X_test) // batch_size + 1
    
        running_loss = 0.0
        total_acc = 0.0
    
        for i in range(num_batches):
            input_batch = X_test[i*batch_size:(i+1)*batch_size][0]
            output_batch = [[y_test[k] for k in range(i*batch_size, (i+1)*batch_size)]]
    
            _, acc, loss = self._fit_batch(input_batch, output_batch, False)
    
            running_loss += loss * len(output_batch)
            total_acc += acc * len(output_batch)
    
        avg_loss = running_loss / (len(X_test) * max(len(y_pred) for y_pred in output_batch))
        avg_acc = total_acc / (len(X_test) * max(len(y_pred) for y_pred in output_batch))
    
        return avg_loss, avg_acc
    
    def _fit_batch(self, inputs, outputs, training=True):
        states_value = self.encoder_model.predict(inputs[:, :-1])
        target_seq = np.array([[outputs[i][j] for j in range(len(outputs[i]))]
                               for i in range(len(outputs))]).transpose((1, 0, 2)).reshape((-1, ))
    
        decoder_inputs = np.concatenate(([[-1]]*states_value.shape[0]), axis=-1).astype(np.float32)
        preds, h, c = self.decoder_model.predict([decoder_inputs, states_value])[:3]
    
        acc = sum(target_seq == np.argmax(preds, axis=-1))/len(target_seq)
    
        if not training:
            return pred
    
        y_true = tf.one_hot(target_seq, depth=preds.shape[-1])
        mask = tf.math.logical_not(tf.math.equal(target_seq, 0))
        mask = tf.cast(mask, dtype=tf.float32)
        loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true, logits=preds) * mask)
    
        grads = tape.gradient(loss, self.decoder_model.trainable_weights)
        self.optimizer.apply_gradients(zip(grads, self.decoder_model.trainable_weights))
    
        return loss.numpy(), acc, 0.0
    
    if __name__ == '__main__':
    pass
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    if __name__ == '__main__':
    # Load dataset
    (X_train, y_train), (X_test, y_test) = load_dataset()
    
    # Define hyperparameters
    VOCAB_SIZE = 20000
    EMBED_DIM = 32
    HIDDEN_DIM = 128
    DROPOUT_RATE = 0.5
    BATCH_SIZE = 64
    EPOCHS = 50
    VAL_SPLIT = (.2,.8)
    
    # Create model instance
    seq2seq = Seq2SeqModel(VOCAB_SIZE, EMBED_DIM, HIDDEN_DIM, DROPOUT_RATE)
    
    # Compile the model
    seq2seq.compile()
    
    # Fit the model
    history = seq2seq.fit(X_train, y_train, BATCH_SIZE, EPOCHS, VAL_SPLIT)
    
    # Evaluate the model
    score = seq2seq.evaluate(X_test, y_test, batch_size=BATCH_SIZE)
    print('Test Loss:', score[0])
    print('Test Accuracy:', score[1])
    
    # Plot accuracy and loss curves over time
    plt.plot(history['loss'], label='Train loss')
    plt.plot(history['accuracy'], label='Train accuracy')
    plt.legend()
    plt.xlabel('# Epochs')
    plt.ylabel('%')
    plt.show()
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读