基于神经网络的文本意图（intent）识别_神经网络与意图识别

了解聊天机器人（chatbots）的工作原理很重要。 聊天机器人的一个基本机制是利用文本分类器进行意图识别 。 我们来看一下人工神经网络（ANN）的内部工作原理。

在这个教程中，我们将使用2层神经元（1个隐层）和词袋（bag of words）方法来组织我们的训练数据。 文本分类的方法有三种 ： 模式匹配 ， 传统算法和神经网络 。 虽然使用多项朴素贝叶斯（Multinomial Naive Bayes）的算法出乎意料地有效，但它有三个基本缺陷：

• MNB算法的输出是一个分值（score）而不是概率（probability）。 我们更希望得到一个概率，以便忽略低于某个阈值的预测。 这类似于VHF无线电中的“噪音抑制”机制。
• MNB算法只能从分类的正例样本中学习模式，然而从分类的负例样本中进行学习也是非常重要的。
• 不平衡的训练数据会导致NMB分类器的分值扭曲，迫使算法按照不同分类的数据集的大小来调整分值 。 这不是理想的方案。

与朴素（naive）相对应，文本分类器并不是试图理解一个句子的意思 ，而只是进行分类。理解这一点很重要， 实际上所谓的智能聊天机器人并不能真的理解人类的语言，不过这是另一回事 了。

如果你是人工神经网络的新手， 那么点这里了解它们是如何工作的 。

要理解用于分类的传统算法，请参见此处 。

现在，让我们按以下步骤实现一个用于意图识别的文本分类神经网络：

1. 选择技术栈
2. 准备训练数据
3. 预处理数据
4. 迭代 ：代码实现 + 测试 + 模型调整
5. 抽象思考

代码在这里，我们使用iPython Notebook，对于数据科学项目而言，它是一种超高效的工作方式。 代码开发语言是Python。

我们使用NTLK进行自然语言处理。 首先需要一种方法将句子可靠地切分为单词（tokenize）并进行词干提取（stem）：

# use natural language toolkit
import nltk
from nltk.stem.lancaster import LancasterStemmer
import os
import json
import datetime
stemmer = LancasterStemmer()
1
2
3
4
5
6
7

我们的训练数据中，12个句子分别属于3类意图（intent）：greeting、goodbye和sandwich：

# 3 classes of training data
training_data = []
training_data.append({"class":"greeting", "sentence":"how are you?"})
training_data.append({"class":"greeting", "sentence":"how is your day?"})
training_data.append({"class":"greeting", "sentence":"good day"})
training_data.append({"class":"greeting", "sentence":"how is it going today?"})

training_data.append({"class":"goodbye", "sentence":"have a nice day"})
training_data.append({"class":"goodbye", "sentence":"see you later"})
training_data.append({"class":"goodbye", "sentence":"have a nice day"})
training_data.append({"class":"goodbye", "sentence":"talk to you soon"})

training_data.append({"class":"sandwich", "sentence":"make me a sandwich"})
training_data.append({"class":"sandwich", "sentence":"can you make a sandwich?"})
training_data.append({"class":"sandwich", "sentence":"having a sandwich today?"})
training_data.append({"class":"sandwich", "sentence":"what's for lunch?"})
print ("%s sentences in training data" % len(training_data))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

现在我们进行数据预处理：

words = []
classes = []
documents = []
ignore_words = ['?']
# loop through each sentence in our training data
for pattern in training_data:
    # tokenize each word in the sentence
    w = nltk.word_tokenize(pattern['sentence'])
    # add to our words list
    words.extend(w)
    # add to documents in our corpus
    documents.append((w, pattern['class']))
    # add to our classes list
    if pattern['class'] not in classes:
        classes.append(pattern['class'])

# stem and lower each word and remove duplicates
words = [stemmer.stem(w.lower()) for w in words if w not in ignore_words]
words = list(set(words))

# remove duplicates
classes = list(set(classes))

print (len(documents), "documents")
print (len(classes), "classes", classes)
print (len(words), "unique stemmed words", words)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

运行上面的代码，输出结果如下：

12 documents
3 classes ['greeting', 'goodbye', 'sandwich']
26 unique stemmed words ['sandwich', 'hav', 'a', 'how', 'for', 'ar', 'good', 'mak', 'me', 'it', 'day', 'soon', 'nic', 'lat', 'going', 'you', 'today', 'can', 'lunch', 'is', "'s", 'see', 'to', 'talk', 'yo', 'what']
1
2
3

请注意，每个单词都转换为小写并进行了词干提取。 词干提取可以帮助机器理解have和having是一样的。 另外，我们也不关心单词的大小写。

我们将训练数据中的每个句子转化为词袋（bag of words）表示：

下面是转换代码：

# create our training data
training = []
output = []
# create an empty array for our output
output_empty = [0] * len(classes)

# training set, bag of words for each sentence
for doc in documents:
    # initialize our bag of words
    bag = []
    # list of tokenized words for the pattern
    pattern_words = doc[0]
    # stem each word
    pattern_words = [stemmer.stem(word.lower()) for word in pattern_words]
    # create our bag of words array
    for w in words:
        bag.append(1) if w in pattern_words else bag.append(0)

    training.append(bag)
    # output is a '0' for each tag and '1' for current tag
    output_row = list(output_empty)
    output_row[classes.index(doc[1])] = 1
    output.append(output_row)

# sample training/output
i = 0
w = documents[i][0]
print ([stemmer.stem(word.lower()) for word in w])
print (training[i])
print (output[i])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

代码运行的输出结果如下：

['how', 'ar', 'you', '?']
[0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[1, 0, 0]
1
2
3

上述步骤是文本处理中的一个经典环节：每个训练语句都被变换为一个只有0和1的数组，成员的序号对应于单词在语料库中的为止。

例如，对于句子：

['how', 'are', 'you', '?']
1

经过词干提取后，变换为：

['how', 'ar', 'you', '?']
1

然后转换为模型的输入： 因为how在我们的词典中排在第4个，所以在模型输入中，我们将输入的第4个成员置为1，此外，我们决定抛弃?：

[0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
1

这个输入对应于三个意图中的第1类，因此其输出表示为：

 [1,0,0] 
1

请注意，一个句子可以属于多个类（意图）， 或不属于任何类 。

你可以尝试练习、运行上面的代码，直到找到点感觉为止。

机器学习的第一步是要有干净的数据。

接下来，我们实现这个2层神经网络的核心功能：

如果你是人工神经网络方面的新手， 可以点击这里查看它的工作原理 。

我们使用numpy，因为它可以快速进行矩阵乘法计算。

我们使用一个sigmoid函数作为神经元的激活函数。 然后，不断迭代并进行参数调整，直到错误率低到可接受。

下面的代码，实现了词袋处理并将输入句子转换为0、1数组。 这和我们对训练数据的转换完全匹配，这一点对于获得正确的结果是至关重要的。

import numpy as np
import time

# compute sigmoid nonlinearity
def sigmoid(x):
    output = 1/(1+np.exp(-x))
    return output

# convert output of sigmoid function to its derivative
def sigmoid_output_to_derivative(output):
    return output*(1-output)

def clean_up_sentence(sentence):
    # tokenize the pattern
    sentence_words = nltk.word_tokenize(sentence)
    # stem each word
    sentence_words = [stemmer.stem(word.lower()) for word in sentence_words]
    return sentence_words

# return bag of words array: 0 or 1 for each word in the bag that exists in the sentence
def bow(sentence, words, show_details=False):
    # tokenize the pattern
    sentence_words = clean_up_sentence(sentence)
    # bag of words
    bag = [0]*len(words)  
    for s in sentence_words:
        for i,w in enumerate(words):
            if w == s: 
                bag[i] = 1
                if show_details:
                    print ("found in bag: %s" % w)

    return(np.array(bag))

def think(sentence, show_details=False):
    x = bow(sentence.lower(), words, show_details)
    if show_details:
        print ("sentence:", sentence, "\n bow:", x)
    # input layer is our bag of words
    l0 = x
    # matrix multiplication of input and hidden layer
    l1 = sigmoid(np.dot(l0, synapse_0))
    # output layer
    l2 = sigmoid(np.dot(l1, synapse_1))
return l2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

现在我们来实现神经网络的训练函数来调整突触的权重。 不要太紧张，主要用到的知识就是中学数学中的矩阵乘法：

def train(X, y, hidden_neurons=10, alpha=1, epochs=50000, dropout=False, dropout_percent=0.5):

    print ("Training with %s neurons, alpha:%s, dropout:%s %s" % (hidden_neurons, str(alpha), dropout, dropout_percent if dropout else '') )
    print ("Input matrix: %sx%s    Output matrix: %sx%s" % (len(X),len(X[0]),1, len(classes)) )
    np.random.seed(1)

    last_mean_error = 1
    # randomly initialize our weights with mean 0
    synapse_0 = 2*np.random.random((len(X[0]), hidden_neurons)) - 1
    synapse_1 = 2*np.random.random((hidden_neurons, len(classes))) - 1

    prev_synapse_0_weight_update = np.zeros_like(synapse_0)
    prev_synapse_1_weight_update = np.zeros_like(synapse_1)

    synapse_0_direction_count = np.zeros_like(synapse_0)
    synapse_1_direction_count = np.zeros_like(synapse_1)

    for j in iter(range(epochs+1)):

        # Feed forward through layers 0, 1, and 2
        layer_0 = X
        layer_1 = sigmoid(np.dot(layer_0, synapse_0))

        if(dropout):
            layer_1 *= np.random.binomial([np.ones((len(X),hidden_neurons))],1-dropout_percent)[0] * (1.0/(1-dropout_percent))

        layer_2 = sigmoid(np.dot(layer_1, synapse_1))

        # how much did we miss the target value?
        layer_2_error = y - layer_2

        if (j% 10000) == 0 and j > 5000:
            # if this 10k iteration's error is greater than the last iteration, break out
            if np.mean(np.abs(layer_2_error)) < last_mean_error:
                print ("delta after "+str(j)+" iterations:" + str(np.mean(np.abs(layer_2_error))) )
                last_mean_error = np.mean(np.abs(layer_2_error))
            else:
                print ("break:", np.mean(np.abs(layer_2_error)), ">", last_mean_error )
                break

        # in what direction is the target value?
        # were we really sure? if so, don't change too much.
        layer_2_delta = layer_2_error * sigmoid_output_to_derivative(layer_2)

        # how much did each l1 value contribute to the l2 error (according to the weights)?
        layer_1_error = layer_2_delta.dot(synapse_1.T)

        # in what direction is the target l1?
        # were we really sure? if so, don't change too much.
        layer_1_delta = layer_1_error * sigmoid_output_to_derivative(layer_1)

        synapse_1_weight_update = (layer_1.T.dot(layer_2_delta))
        synapse_0_weight_update = (layer_0.T.dot(layer_1_delta))

        if(j > 0):
            synapse_0_direction_count += np.abs(((synapse_0_weight_update > 0)+0) - ((prev_synapse_0_weight_update > 0) + 0))
            synapse_1_direction_count += np.abs(((synapse_1_weight_update > 0)+0) - ((prev_synapse_1_weight_update > 0) + 0))        

        synapse_1 += alpha * synapse_1_weight_update
        synapse_0 += alpha * synapse_0_weight_update

        prev_synapse_0_weight_update = synapse_0_weight_update
        prev_synapse_1_weight_update = synapse_1_weight_update

    now = datetime.datetime.now()

    # persist synapses
    synapse = {'synapse0': synapse_0.tolist(), 'synapse1': synapse_1.tolist(),
               'datetime': now.strftime("%Y-%m-%d %H:%M"),
               'words': words,
               'classes': classes
              }
    synapse_file = "synapses.json"

    with open(synapse_file, 'w') as outfile:
        json.dump(synapse, outfile, indent=4, sort_keys=True)
print ("saved synapses to:", synapse_file)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

现在准备建立神经网络模型 ，我们将把网络中的突触权重保存到一个json文件，也就是我们的模型文件。

你可以尝试不同的梯度下降参数（alpha），来看看它是如何影响错误率的变化。 这个参数帮助我们的模型达到最低的错误率：

synapse_0 += alpha * synapse_0_weight_update

我们在隐层中只使用了20个神经元，因此比较容易进行调节。 这些神经元的连接突触权重将根据训练数据的大小和数值而变化，一个合理的错误率目标是小于10 ^ -3。

X = np.array(training)
y = np.array(output)

start_time = time.time()

train(X, y, hidden_neurons=20, alpha=0.1, epochs=100000, dropout=False, dropout_percent=0.2)

elapsed_time = time.time() - start_time
print ("processing time:", elapsed_time, "seconds")
1
2
3
4
5
6
7
8
9

上面代码的运行结果是：

Training with 20 neurons, alpha:0.1, dropout:False 
Input matrix: 12x26    Output matrix: 1x3
delta after 10000 iterations:0.0062613597435
delta after 20000 iterations:0.00428296074919
delta after 30000 iterations:0.00343930779307
delta after 40000 iterations:0.00294648034566
delta after 50000 iterations:0.00261467859609
delta after 60000 iterations:0.00237219554105
delta after 70000 iterations:0.00218521899378
delta after 80000 iterations:0.00203547284581
delta after 90000 iterations:0.00191211022401
delta after 100000 iterations:0.00180823798397
saved synapses to: synapses.json
processing time: 6.501226902008057 seconds
1
2
3
4
5
6
7
8
9
10
11
12
13
14

现在，synapse.json文件包含了网络中所有的突触权重， 这就是我们的模型。

一旦计算出突触权重，下面的classify()函数就是进行分类的核心：〜15行代码。

注意：如果训练数据发生了变化，我们需要重新计算整个模型。 对于一个非常大的数据集，这可能需要花费不少的时间。

现在我们可以预测一个句子属于某个分类的概率。 预测速度很快，因为它就是think()函数中的点积计算：

# probability threshold
ERROR_THRESHOLD = 0.2
# load our calculated synapse values
synapse_file = 'synapses.json' 
with open(synapse_file) as data_file: 
    synapse = json.load(data_file) 
    synapse_0 = np.asarray(synapse['synapse0']) 
    synapse_1 = np.asarray(synapse['synapse1'])

def classify(sentence, show_details=False):
    results = think(sentence, show_details)

    results = [[i,r] for i,r in enumerate(results) if r>ERROR_THRESHOLD ] 
    results.sort(key=lambda x: x[1], reverse=True) 
    return_results =[[classes[r[0]],r[1]] for r in results]
    print ("%s \n classification: %s" % (sentence, return_results))
    return return_results

classify("sudo make me a sandwich")
classify("how are you today?")
classify("talk to you tomorrow")
classify("who are you?")
classify("make me some lunch")
classify("how was your lunch today?")
print()
classify("good day", show_details=True)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

运行结果如下：

sudo make me a sandwich 
 [['sandwich', 0.99917711814437993]]
how are you today? 
 [['greeting', 0.99864563257858363]]
talk to you tomorrow 
 [['goodbye', 0.95647479275905511]]
who are you? 
 [['greeting', 0.8964283843977312]]
make me some lunch 
 [['sandwich', 0.95371924052636048]]
how was your lunch today? 
 [['greeting', 0.99120883810944971], ['sandwich', 0.31626066870883057]]
1
2
3
4
5
6
7
8
9
10
11
12

你可以尝试一些其他的句子，也可以添加训练数据来改进和扩展模型。

有些句子会产生多个预测（都超过指定的阈值）。 你需要根据具体的应用来设置正确的阈值。 并非所有的文本分类场景都是相同的： 有些场景需要比其他方案更高的置信度。

上面代码中最后的那个分类调用使用show_details参数展示了一些内部的实现细节：

found in bag: good
found in bag: day
sentence: good day 
 bow: [0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
good day 
 [['greeting', 0.99664077655648697]]
1
2
3
4
5
6

注意这个句子的词袋表示，其中有两个单词可以我们的词库相匹配。 神经网络也从0中得到了学习，即那些与词库不匹配的单词。

很容易通过一个示例句子来展示低概率的分类预测，其中’a’（常用词）是唯一的匹配，例如：

found in bag: a
sentence: a burrito! 
 bow: [0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
a burrito! 
 [['sandwich', 0.61776860634647834]]
1
2
3
4
5

现在你有了一个构建聊天机器人的基本工具，它能够处理大量的类 （意图），并适用于对有限或大量的训练数据进行分类。 也很容易在模型中添加一个或多个新的意图。

感谢 Alexander Pinto 。

原文： Text Classification using Neural Networks