自然語言學習12-聊天機器人

自動問答（Question Answering，QA）

自動問答主要研究的內容和關鍵科學問題如下：

1. 問句理解：給定用戶問題，自動問答首先需要理解用戶所提問題。用戶問句的語義理解包含詞法分析、句法分析、語義分析等多項關鍵技術，需要從文本的多個維度理解其中包含的語義內容。

2. 文本信息抽取：自動問答系統需要在已有語料庫、知識庫或問答庫中匹配相關的信息，並抽取出相應的答案。

3. 知識推理：自動問答中，由於語料庫、知識庫和問答庫本身的覆蓋度有限，並不是所有問題都能直接找到答案。這就需要在已有的知識體系中，通過知識推理的手段獲取這些隱含的答案。

pip install chatterbot

error：

 

1. 手動設置語料，體驗基於規則的聊天機器人回答。

from chatterbot import ChatBot
from chatterbot.trainers import ListTrainer
Chinese_bot = ChatBot("Training demo") #創建一個新的實例
Chinese_bot.set_trainer(ListTrainer)
Chinese_bot.train([
    '親，在嗎？',
    '親，在呢',
    '這件衣服的號碼大小標準嗎？',
    '親，標準呢，請放心下單吧。',
    '有紅色的嗎？',
    '有呢，目前有白紅藍3種色調。',
])

測試

# 測試一下
question = '親，在嗎'
print(question)
response = Chinese_bot.get_response(question)
print(response)
print("\n")
question = '有紅色的嗎？'
print(question)
response = Chinese_bot.get_response(question)
print(response)

error

 

1）首先載入語料

lines = open("QQ.txt","r",encoding='gbk').readlines()
sec = [ line.strip() for line in lines]

2）訓練模型

from chatterbot import ChatBot
from chatterbot.trainers import ListTrainer
Chinese_bot = ChatBot("Training")
Chinese_bot.set_trainer(ListTrainer)
Chinese_bot.train(sec)

如果訓練過程很慢，可以在第一步中加入如下代碼，即只取前1000條進行訓練：

sec = sec[0:1000]

（3）最後，對訓練好的模型進行測試

基於 深度學習的Seq2Seq 模型製作中文聊天機器人

RNN結構：

• One To One 結構，僅僅只是簡單的給一個輸入得到一個輸出，此處並未體現序列的特徵，例如圖像分類場景。
• One To Many 結構，給一個輸入得到一系列輸出，這種結構可用於生產圖片描述的場景。
• Many To One 結構，給一系列輸入得到一個輸出，這種結構可用於文本情感分析，對一些列的文本輸入進行分類，看是消極還是積極情感。
• Many To Many 結構，給一系列輸入得到一系列輸出，這種結構可用於翻譯或聊天對話場景，將輸入的文本轉換成另外一系列文本。
• 同步 Many To Many 結構，它是經典的 RNN 結構，前一輸入的狀態會帶到下一個狀態中，而且每個輸入都會對應一個輸出，我們最熟悉的應用場景是字符預測，同樣也可以用於視頻分類，對視頻的幀打標籤。

在 Many To Many 的兩種模型中，第四和第五種是有差異的，經典 RNN 結構的輸入和輸出序列必須要等長，它的應用場景也比較有限。而第四種，輸入和輸出序列可以不等長，這種模型便是 Seq2Seq 模型，即 Sequence to Sequence。它實現了從一個序列到另外一個序列的轉換，比如 Google 曾用 Seq2Seq 模型加 Attention 模型實現了翻譯功能，類似的還可以實現聊天機器人對話模型。經典的 RNN 模型固定了輸入序列和輸出序列的大小，而 Seq2Seq 模型則突破了該限制。

Seq2Seq 屬於 Encoder-Decoder 結構，這裏看看常見的 Encoder-Decoder 結構。基本思想就是利用兩個 RNN，一個 RNN 作爲 Encoder，另一個 RNN 作爲 Decoder。Encoder 負責將輸入序列壓縮成指定長度的向量，這個向量就可以看成是這個序列的語義，這個過程稱爲編碼，如下圖，獲取語義向量最簡單的方式就是直接將最後一個輸入的隱狀態作爲語義向量。也可以對最後一個隱含狀態做一個變換得到語義向量，還可以將輸入序列的所有隱含狀態做一個變換得到語義變量。

通過 Keras 實現一個 LSTM_Seq2Seq 自動問答機器人

1. 語料準備。

語料使用 Tab 鍵 \t 把問題和答案區分，每一對爲一行。其中，語料爲爬蟲爬取的工程機械網站的問答。

2. 模型構建和訓練。

第一步，引入需要的包：

from keras.models import Model
from keras.layers import Input, LSTM, Dense
import numpy as np
import pandas as pd

第二步，定義模型超參數、迭代次數、語料路徑：

#Batch size 的大小
batch_size = 32  
# 迭代次數epochs
epochs = 100
# 編碼空間的維度Latent dimensionality 
latent_dim = 256  
# 要訓練的樣本數
num_samples = 5000 
#設置語料的路徑
data_path = 'E://nlp//12//files.txt'

第三步，把語料向量化：

#把數據向量話
input_texts = []
target_texts = []
input_characters = set()
target_characters = set()

with open(data_path, 'r', encoding='utf-8') as f:
    lines = f.read().split('\n')
for line in lines[: min(num_samples, len(lines) - 1)]:
    #print(line)
    input_text, target_text = line.split('\t')
    # We use "tab" as the "start sequence" character
    # for the targets, and "\n" as "end sequence" character.
    target_text = target_text[0:100]
    target_text = '\t' + target_text + '\n'
    input_texts.append(input_text)
    target_texts.append(target_text)

    for char in input_text:
        if char not in input_characters:
            input_characters.add(char)
    for char in target_text:
        if char not in target_characters:
            target_characters.add(char)

input_characters = sorted(list(input_characters))
target_characters = sorted(list(target_characters))
num_encoder_tokens = len(input_characters)
num_decoder_tokens = len(target_characters)
max_encoder_seq_length = max([len(txt) for txt in input_texts])
max_decoder_seq_length = max([len(txt) for txt in target_texts])

print('Number of samples:', len(input_texts))
print('Number of unique input tokens:', num_encoder_tokens)
print('Number of unique output tokens:', num_decoder_tokens)
print('Max sequence length for inputs:', max_encoder_seq_length)
print('Max sequence length for outputs:', max_decoder_seq_length)

input_token_index = dict(
    [(char, i) for i, char in enumerate(input_characters)])
target_token_index = dict(
    [(char, i) for i, char in enumerate(target_characters)])

encoder_input_data = np.zeros(
    (len(input_texts), max_encoder_seq_length, num_encoder_tokens),dtype='float32')
decoder_input_data = np.zeros(
    (len(input_texts), max_decoder_seq_length, num_decoder_tokens),dtype='float32')
decoder_target_data = np.zeros(
    (len(input_texts), max_decoder_seq_length, num_decoder_tokens),dtype='float32')

for i, (input_text, target_text) in enumerate(zip(input_texts, target_texts)):
    for t, char in enumerate(input_text):
        encoder_input_data[i, t, input_token_index[char]] = 1.
    for t, char in enumerate(target_text):
        # decoder_target_data is ahead of decoder_input_data by one timestep
        decoder_input_data[i, t, target_token_index[char]] = 1.
        if t > 0:
            # decoder_target_data will be ahead by one timestep
            # and will not include the start character.
            decoder_target_data[i, t - 1, target_token_index[char]] = 1.

第四步，LSTM_Seq2Seq 模型定義、訓練和保存：

encoder_inputs = Input(shape=(None, num_encoder_tokens))
encoder = LSTM(latent_dim, return_state=True)
encoder_outputs, state_h, state_c = encoder(encoder_inputs)
# 輸出 `encoder_outputs` 
encoder_states = [state_h, state_c]

# 狀態 `encoder_states` 
decoder_inputs = Input(shape=(None, num_decoder_tokens))
decoder_lstm = LSTM(latent_dim, return_sequences=True, return_state=True)
decoder_outputs, _, _ = decoder_lstm(decoder_inputs,
                       initial_state=encoder_states)
decoder_dense = Dense(num_decoder_tokens, activation='softmax')
decoder_outputs = decoder_dense(decoder_outputs)

# 定義模型
model = Model([encoder_inputs, decoder_inputs], decoder_outputs)

# 訓練
model.compile(optimizer='rmsprop', loss='categorical_crossentropy')
model.fit([encoder_input_data, decoder_input_data], decoder_target_data,
          batch_size=batch_size,
          epochs=epochs,
          validation_split=0.2)
# 保存模型
model.save('s2s.h5')

第五步，Seq2Seq 的 Encoder 操作：

encoder_model = Model(encoder_inputs, encoder_states)

decoder_state_input_h = Input(shape=(latent_dim,))
decoder_state_input_c = Input(shape=(latent_dim,))
decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]
decoder_outputs, state_h, state_c = decoder_lstm(
    decoder_inputs, initial_state=decoder_states_inputs)
decoder_states = [state_h, state_c]
decoder_outputs = decoder_dense(decoder_outputs)
decoder_model = Model(
    [decoder_inputs] + decoder_states_inputs,
    [decoder_outputs] + decoder_states)

第六步，把索引和分詞轉成序列：

reverse_input_char_index = dict(
    (i, char) for char, i in input_token_index.items())
reverse_target_char_index = dict(
    (i, char) for char, i in target_token_index.items())

第七步，定義預測函數，先使用預模型預測，然後編碼成漢字結果：

def decode_sequence(input_seq):
    # Encode the input as state vectors.
    states_value = encoder_model.predict(input_seq)
    #print(states_value)

    # Generate empty target sequence of length 1.
    target_seq = np.zeros((1, 1, num_decoder_tokens))
    # Populate the first character of target sequence with the start character.
    target_seq[0, 0, target_token_index['\t']] = 1.

    # Sampling loop for a batch of sequences
    # (to simplify, here we assume a batch of size 1).
    stop_condition = False
    decoded_sentence = ''
    while not stop_condition:
        output_tokens, h, c = decoder_model.predict(
            [target_seq] + states_value)

        # Sample a token
        sampled_token_index = np.argmax(output_tokens[0, -1, :])
        sampled_char = reverse_target_char_index[sampled_token_index]
        decoded_sentence += sampled_char
        if (sampled_char == '\n' or
           len(decoded_sentence) > max_decoder_seq_length):
            stop_condition = True

        # Update the target sequence (of length 1).
        target_seq = np.zeros((1, 1, num_decoder_tokens))
        target_seq[0, 0, sampled_token_index] = 1.
        # 更新狀態
        states_value = [h, c]
    return decoded_sentence

3. 模型預測。

定義一個預測函數：

def predict_ans(question):
        inseq = np.zeros((len(question), max_encoder_seq_length, num_encoder_tokens),dtype='float16')
        decoded_sentence = decode_sequence(inseq)
        return decoded_sentence

 

print('Decoded sentence:', predict_ans("挖機履帶掉了怎麼裝上去"))