TensorFlow 机器学习秘籍第二版：6~8（3）-阿里云开发者社区

TensorFlow 机器学习秘籍第二版：6~8（2）https://developer.aliyun.com/article/1426838

实现 TF-IDF

由于我们可以为每个单词选择嵌入，我们可能会决定更改某些单词的加权。一种这样的策略是增加有用的单词和减轻过度常见或罕见单词的权重。我们将在此秘籍中探索的嵌入是尝试实现此目的。

准备

TF-IDF 是一个缩写，代表文本频率 - 反向文档频率。该术语基本上是每个单词的文本频率和反向文档频率的乘积。

在前面的秘籍中，我们介绍了词袋方法，它为句子中每个单词的出现赋值为 1。这可能并不理想，因为每个类别的句子（前一个秘籍中的垃圾邮件和非垃圾邮件）很可能具有the，and和其他单词的相同频率，而诸如Viagra和sale之类的单词]可能应该更加重视查明文本是否是垃圾邮件。

首先，我们要考虑词频。在这里，我们考虑单个条目中单词出现的频率。这部分（TF）的目的是找到在每个条目中看起来很重要的项。

但是the和and等词可能会在每个条目中频繁出现。我们希望减轻这些单词的重要性，因此将前面的文本频率（TF）乘以整个文档频率的倒数可能有助于找到重要的单词。然而，由于文本集（语料库）可能非常大，因此通常采用逆文档频率的对数。这为我们留下了每个文档条目中每个单词的 TF-IDF 的以下公式：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d1ggXhlW-1681566911068)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/tf-ml-cookbook-2e-zh/img/6d9df72e-4e84-45f4-864f-32730248af36.png)]

这里w[tf]是文档中的单词频率，w[df]是所有文档中这些单词的总频率。有意义的是，TF-IDF 的高值可能表示在确定文档内容时非常重要的单词。

创建 TF-IDF 向量要求我们将所有文本加载到内存中，并在开始训练模型之前计算每个单词的出现次数。因此，它没有在 TensorFlow 中完全实现，因此我们将使用 scikit-learn 来创建我们的 TF-IDF 嵌入，但是使用 TensorFlow 来适应逻辑模型。

操作步骤

我们将按如下方式处理秘籍：

我们将从加载必要的库开始。这次，我们正在为我们的文本加载 scikit-learn TF-IDF 预处理库。使用以下代码执行此操作：

import tensorflow as tf 
import matplotlib.pyplot as plt 
import csv 
import numpy as np 
import os 
import string 
import requests 
import io 
import nltk 
from zipfile import ZipFile 
from sklearn.feature_extraction.text import TfidfVectorizer

我们将开始一个图会话，并为我们的词汇表声明我们的批量大小和最大特征大小：

sess = tf.Session() 
batch_size= 200 
max_features = 1000

接下来，我们将从 Web 或我们的temp数据文件夹中加载数据（如果我们之前已保存过）。使用以下代码执行此操作：

save_file_name = os.path.join('temp','temp_spam_data.csv') 
if os.path.isfile(save_file_name): 
    text_data = [] 
    with open(save_file_name, 'r') as temp_output_file: 
        reader = csv.reader(temp_output_file) 
        for row in reader: 
            text_data.append(row) 
else: 
    zip_url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00228/smsspamcollection.zip' 
    r = requests.get(zip_url) 
    z = ZipFile(io.BytesIO(r.content)) 
    file = z.read('SMSSpamCollection') 
    # Format Data 
    text_data = file.decode() 
    text_data = text_data.encode('ascii',errors='ignore') 
    text_data = text_data.decode().split('\n') 
    text_data = [x.split('\t') for x in text_data if len(x)>=1] 
    # And write to csv 
    with open(save_file_name, 'w') as temp_output_file: 
        writer = csv.writer(temp_output_file) 
        writer.writerows(text_data) 
texts = [x[1] for x in text_data] 
target = [x[0] for x in text_data] 
# Relabel 'spam' as 1, 'ham' as 0 
target = [1\. if x=='spam' else 0\. for x in target]

就像前面的秘籍一样，我们将通过将所有内容转换为小写，删除标点符号并删除数字来减少词汇量：

# Lower case 
texts = [x.lower() for x in texts] 
# Remove punctuation 
texts = [''.join(c for c in x if c not in string.punctuation) for x in texts] 
# Remove numbers 
texts = [''.join(c for c in x if c not in '0123456789') for x in texts] 
# Trim extra whitespace 
texts = [' '.join(x.split()) for x in texts]

为了使用 scikt-learn 的 TF-IDF 处理函数，我们必须告诉它如何标记我们的句子。通过这个，我们只是指如何将句子分解为相应的单词。我们已经为我们构建了一个很好的标记器：nltk包可以很好地将句子分解为相应的单词：

def tokenizer(text): 
    words = nltk.word_tokenize(text) 
    return words 
# Create TF-IDF of texts 
tfidf = TfidfVectorizer(tokenizer=tokenizer, stop_words='english', max_features=max_features) 
sparse_tfidf_texts = tfidf.fit_transform(texts)

接下来，我们将数据集分解为测试和训练集。使用以下代码执行此操作：

train_indices = np.random.choice(sparse_tfidf_texts.shape[0], round(0.8*sparse_tfidf_texts.shape[0]), replace=False) 
test_indices = np.array(list(set(range(sparse_tfidf_texts.shape[0])) - set(train_indices))) 
texts_train = sparse_tfidf_texts[train_indices] 
texts_test = sparse_tfidf_texts[test_indices] 
target_train = np.array([x for ix, x in enumerate(target) if ix in train_indices]) 
target_test = np.array([x for ix, x in enumerate(target) if ix in test_indices])

现在我们声明我们的逻辑回归模型变量和我们的数据占位符：

A = tf.Variable(tf.random_normal(shape=[max_features,1])) 
b = tf.Variable(tf.random_normal(shape=[1,1])) 
# Initialize placeholders 
x_data = tf.placeholder(shape=[None, max_features], dtype=tf.float32) 
y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

我们现在可以声明模型操作和损失函数。请记住，逻辑回归的 sigmoid 部分在我们的损失函数中。使用以下代码执行此操作：

model_output = tf.add(tf.matmul(x_data, A), b) 
loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=model_output, labels=y_target))

我们将预测和精度函数添加到图中，以便在我们的模型训练时我们可以看到训练和测试集的准确率：

prediction = tf.round(tf.sigmoid(model_output)) 
predictions_correct = tf.cast(tf.equal(prediction, y_target), tf.float32) 
accuracy = tf.reduce_mean(predictions_correct)

然后我们将声明一个优化器并初始化我们的图变量：

my_opt = tf.train.GradientDescentOptimizer(0.0025) 
train_step = my_opt.minimize(loss) 
# Intitialize Variables 
init = tf.global_variables_initializer() 
sess.run(init)

我们现在将训练我们的模型超过 10,000 代，并记录每 100 代的测试/训练损失和准确率，每 500 代打印一次。使用以下代码执行此操作：

train_loss = [] 
test_loss = [] 
train_acc = [] 
test_acc = [] 
i_data = [] 
for i in range(10000): 
    rand_index = np.random.choice(texts_train.shape[0], size=batch_size) 
    rand_x = texts_train[rand_index].todense() 
    rand_y = np.transpose([target_train[rand_index]]) 
    sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y}) 
    # Only record loss and accuracy every 100 generations 
    if (i+1)%100==0: 
        i_data.append(i+1) 
        train_loss_temp = sess.run(loss, feed_dict={x_data: rand_x, y_target: rand_y}) 
        train_loss.append(train_loss_temp) 
        test_loss_temp = sess.run(loss, feed_dict={x_data: texts_test.todense(), y_target: np.transpose([target_test])}) 
        test_loss.append(test_loss_temp) 
        train_acc_temp = sess.run(accuracy, feed_dict={x_data: rand_x, y_target: rand_y}) 
        train_acc.append(train_acc_temp) 
        test_acc_temp = sess.run(accuracy, feed_dict={x_data: texts_test.todense(), y_target: np.transpose([target_test])}) 
        test_acc.append(test_acc_temp) 
    if (i+1)%500==0: 
        acc_and_loss = [i+1, train_loss_temp, test_loss_temp, train_acc_temp, test_acc_temp] 
        acc_and_loss = [np.round(x,2) for x in acc_and_loss] 
        print('Generation # {}. Train Loss (Test Loss): {:.2f} ({:.2f}). Train Acc (Test Acc): {:.2f} ({:.2f})'.format(*acc_and_loss))

这产生以下输出：

Generation # 500\. Train Loss (Test Loss): 0.69 (0.73). Train Acc (Test Acc): 0.62 (0.57) 
Generation # 1000\. Train Loss (Test Loss): 0.62 (0.63). Train Acc (Test Acc): 0.68 (0.66) 
... 
Generation # 9500\. Train Loss (Test Loss): 0.39 (0.45). Train Acc (Test Acc): 0.89 (0.85) 
Generation # 10000\. Train Loss (Test Loss): 0.48 (0.45). Train Acc (Test Acc): 0.84 (0.85)

以下是绘制训练和测试装置的准确率和损耗的绘图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0nGx8Vd0-1681566911068)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/tf-ml-cookbook-2e-zh/img/46d64e8f-a3e6-42db-abd6-d58abebce4c8.png)]

图 2：根据 TF-IDF 值构建的物流垃圾邮件模型的交叉熵损失

训练和测试精度图如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4wayuE1j-1681566911069)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/tf-ml-cookbook-2e-zh/img/cfd1bce3-764c-4ddf-9f6c-847e76d7fdf7.png)]

图 3：根据 TF-IDF 值构建的逻辑垃圾邮件模型的训练和测试集精度

工作原理

使用模型的 TF-IDF 值增加了我们对先前的词袋模型的预测，从 80% 的准确率到接近 90% 的准确率。我们通过使用 scikit-learn 的 TF-IDF 词汇处理函数并使用这些 TF-IDF 值进行逻辑回归来实现这一目标。

虽然我们可能已经解决了重要性这个问题，但我们还没有解决字序问题。词袋和 TF-IDF 都没有考虑句子中的单词的顺序特征。我们将在接下来的几节中尝试解决这个问题，这将向我们介绍 word2vec 技术。

使用 Skip-Gram 嵌入

在之前的秘籍中，我们在训练模型之前决定了我们的文本嵌入。使用神经网络，我们可以使嵌入值成为训练过程的一部分。我们将探索的第一个这样的方法叫做 Skip-Gram 嵌入。

准备

在此秘籍之前，我们没有考虑与创建单词嵌入相关的单词顺序。 2013 年初，Tomas Mikolov 和谷歌的其他研究人员撰写了一篇关于创建解决这个问题的单词嵌入的论文，他们将他们的方法命名为 word2vec。

基本思想是创建捕获单词关系方面的单词嵌入。我们试图了解各种单词如何相互关联。这些嵌入可能如何表现的一些示例如下：

king - man + woman = queen

India pale ale - hops + malt = stout

如果我们只考虑它们之间的位置关系，我们可能会实现这样的数字表示。如果我们能够分析足够大的相关文档来源，我们可能会发现在我们的文本中，king，man和queen这两个词在彼此之间相互提及。如果我们也知道man和woman以不同的方式相关，那么我们可以得出结论，man是king，因为woman是queen，依此类推。

为了找到这样的嵌入，我们将使用一个神经网络来预测给定输入字的周围单词。我们可以轻松地切换它并尝试在给定一组周围单词的情况下预测目标单词，但我们将从前面的方法开始。两者都是 word2vec 过程的变体，但是从目标词预测周围词（上下文）的前述方法称为 Skip-Gram 模型。在下一个秘籍中，我们将实现另一个方法，从上下文预测目标词，这称为连续词袋方法（CBOW）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BPZeDUTP-1681566911069)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/tf-ml-cookbook-2e-zh/img/33e5cd5b-a002-43db-af41-8826c3cd5fc2.png)]

图 4：word2vec 的 Skip-Gram 实现的图示。 Skip-Gram 预测目标词的上下文窗口（每侧窗口大小为 1）。

对于这个秘籍，我们将在康奈尔大学的一组电影评论数据上实现 Skip-Gram 模型。 word2vec 的 CBOW 方法将在下一个秘籍中实现。

操作步骤

对于这个秘籍，我们将创建几个辅助函数。这些函数将加载数据，正则化文本，生成词汇表并生成数据批量。只有在这之后我们才开始训练我们的单词嵌入。为了清楚起见，我们不是预测任何目标变量，而是我们将拟合单词嵌入：

首先，我们将加载必要的库并启动图会话：

import tensorflow as tf 
import matplotlib.pyplot as plt 
import numpy as np 
import random 
import os 
import string 
import requests 
import collections 
import io 
import tarfile 
import urllib.request 
from nltk.corpus import stopwords 
sess = tf.Session()

然后我们声明一些模型参数。我们将一次查看 50 对单词嵌入（批量大小）。每个单词的嵌入大小将是一个长度为 200 的向量，我们只考虑 10,000 个最常用的单词（每隔一个单词将被归类为未知单词）。我们将训练 5 万代，并每 500 代打印一次。然后我们将声明一个我们将在损失函数中使用的num_sampled变量（我们将在后面解释），并且我们还声明了我们的 Skip-Gram 窗口大小。在这里，我们将窗口大小设置为 2，因此我们将查看目标每侧的周围两个单词。我们将通过名为nltk的 Python 包设置我们的停用词。我们还想要一种方法来检查我们的单词嵌入是如何执行的，因此我们将选择一些常见的电影评论单词并从每 2,000 次迭代中打印出最近的邻居单词：

batch_size = 50 
embedding_size = 200 
vocabulary_size = 10000 
generations = 50000 
print_loss_every = 500 
num_sampled = int(batch_size/2) 
window_size = 2 
stops = stopwords.words('english') 
print_valid_every = 2000 
valid_words = ['cliche', 'love', 'hate', 'silly', 'sad']

接下来，我们将声明我们的数据加载函数，该函数会检查以确保在下载之前我们没有下载数据。否则，如果之前保存了数据，它将从磁盘加载数据。使用以下代码执行此操作：

def load_movie_data(): 
    save_folder_name = 'temp' 
    pos_file = os.path.join(save_folder_name, 'rt-polarity.pos') 
    neg_file = os.path.join(save_folder_name, 'rt-polarity.neg') 
    # Check if files are already downloaded 
    if os.path.exists(save_folder_name): 
        pos_data = [] 
        with open(pos_file, 'r') as temp_pos_file: 
            for row in temp_pos_file: 
                pos_data.append(row) 
        neg_data = [] 
        with open(neg_file, 'r') as temp_neg_file: 
            for row in temp_neg_file: 
                neg_data.append(row) 
    else: # If not downloaded, download and save 
        movie_data_url = 'http://www.cs.cornell.edu/people/pabo/movie-review-data/rt-polaritydata.tar.gz' 
        stream_data = urllib.request.urlopen(movie_data_url) 
        tmp = io.BytesIO() 
        while True: 
            s = stream_data.read(16384) 
            if not s:   
                break 
            tmp.write(s) 
            stream_data.close() 
            tmp.seek(0) 
        tar_file = tarfile.open(fileobj=tmp, mode='r:gz') 
        pos = tar_file.extractfile('rt-polaritydata/rt-polarity.pos') 
        neg = tar_file.extractfile('rt-polaritydata/rt-polarity.neg') 
        # Save pos/neg reviews 
        pos_data = [] 
        for line in pos: 
            pos_data.append(line.decode('ISO-8859-1').encode('ascii',errors='ignore').decode()) 
        neg_data = [] 
        for line in neg: 
            neg_data.append(line.decode('ISO-8859-1').encode('ascii',errors='ignore').decode()) 
        tar_file.close() 
        # Write to file 
        if not os.path.exists(save_folder_name): 
            os.makedirs(save_folder_name) 
        # Save files 
        with open(pos_file, 'w') as pos_file_handler: 
            pos_file_handler.write(''.join(pos_data)) 
        with open(neg_file, 'w') as neg_file_handler: 
            neg_file_handler.write(''.join(neg_data)) 
    texts = pos_data + neg_data 
    target = [1]*len(pos_data) + [0]*len(neg_data) 
    return(texts, target) 
texts, target = load_movie_data()

接下来，我们将为文本创建正则化函数。此函数将输入字符串列表并使其为小写，删除标点，删除数字，删除额外的空格，并删除停用词。使用以下代码执行此操作：

def normalize_text(texts, stops): 
    # Lower case 
    texts = [x.lower() for x in texts] 
    # Remove punctuation 
    texts = [''.join(c for c in x if c not in string.punctuation) for x in texts] 
    # Remove numbers 
    texts = [''.join(c for c in x if c not in '0123456789') for x in texts] 
    # Remove stopwords 
    texts = [' '.join([word for word in x.split() if word not in (stops)]) for x in texts] 
    # Trim extra whitespace 
    texts = [' '.join(x.split()) for x in texts] 
    return(texts) 
texts = normalize_text(texts, stops)

为了确保我们所有的电影评论都能提供信息，我们应该确保它们足够长，以包含重要的单词关系。我们会随意将其设置为三个或更多单词：

target = [target[ix] for ix, x in enumerate(texts) if len(x.split()) > 2] 
texts = [x for x in texts if len(x.split()) > 2]

为了构建我们的词汇表，我们将创建一个函数来创建一个带有计数的单词字典。任何不常见的词都不会使我们的词汇量大小被截止，将被标记为RARE。使用以下代码执行此操作：

def build_dictionary(sentences, vocabulary_size): 
    # Turn sentences (list of strings) into lists of words 
    split_sentences = [s.split() for s in sentences] 
    words = [x for sublist in split_sentences for x in sublist] 
    # Initialize list of [word, word_count] for each word, starting with unknown 
    count = [['RARE', -1]] 
    # Now add most frequent words, limited to the N-most frequent (N=vocabulary size) 
count.extend(collections.Counter(words).most_common(vocabulary_size-1)) 
    # Now create the dictionary 
    word_dict = {} 
    # For each word, that we want in the dictionary, add it, then make it the value of the prior dictionary length 
    for word, word_count in count: 
        word_dict[word] = len(word_dict) 
    return(word_dict)

我们需要一个函数将一个句子列表转换为单词索引列表，我们可以将它们传递给嵌入查找函数。使用以下代码执行此操作：

def text_to_numbers(sentences, word_dict): 
    # Initialize the returned data 
    data = [] 
    for sentence in sentences: 
        sentence_data = [] 
        # For each word, either use selected index or rare word index 
        for word in sentence: 
            if word in word_dict: 
                word_ix = word_dict[word] 
            else: 
                word_ix = 0 
            sentence_data.append(word_ix) 
        data.append(sentence_data) 
    return data

现在我们可以实际创建我们的字典并将我们的句子列表转换为单词索引列表：

word_dictionary = build_dictionary(texts, vocabulary_size) 
word_dictionary_rev = dict(zip(word_dictionary.values(), word_dictionary.keys())) 
text_data = text_to_numbers(texts, word_dictionary)

从前面的单词字典中，我们可以查找我们在步骤 2 中选择的验证字的索引。使用以下代码执行此操作：

valid_examples = [word_dictionary[x] for x in valid_words]

我们现在将创建一个将返回 Skip-Gram 批次的函数。我们想训练一对单词，其中一个单词是训练输入（来自我们窗口中心的目标单词），另一个单词是从窗口中选择的。例如，句子the cat in the hat可能导致（输入，输出）对，如下所示：（the，in），（cat，in），（the，in），（hat，in）如果是目标词，我们每个方向的窗口大小为 2：

def generate_batch_data(sentences, batch_size, window_size, method='skip_gram'): 
    # Fill up data batch 
    batch_data = [] 
    label_data = [] 
    while len(batch_data) < batch_size: 
        # select random sentence to start 
        rand_sentence = np.random.choice(sentences) 
        # Generate consecutive windows to look at 
        window_sequences = [rand_sentence[max((ix-window_size),0):(ix+window_size+1)] for ix, x in enumerate(rand_sentence)] 
        # Denote which element of each window is the center word of interest 
        label_indices = [ix if ix<window_size else window_size for ix,x in enumerate(window_sequences)] 
        # Pull out center word of interest for each window and create a tuple for each window 
        if method=='skip_gram': 
            batch_and_labels = [(x[y], x[:y] + x[(y+1):]) for x,y in zip(window_sequences, label_indices)] 
            # Make it in to a big list of tuples (target word, surrounding word) 
            tuple_data = [(x, y_) for x,y in batch_and_labels for y_ in y] 
        else: 
            raise ValueError('Method {} not implmented yet.'.format(method)) 
        # extract batch and labels 
        batch, labels = [list(x) for x in zip(*tuple_data)] 
        batch_data.extend(batch[:batch_size]) 
        label_data.extend(labels[:batch_size]) 
    # Trim batch and label at the end 
    batch_data = batch_data[:batch_size] 
    label_data = label_data[:batch_size] 
    # Convert to numpy array 
    batch_data = np.array(batch_data) 
    label_data = np.transpose(np.array([label_data])) 
    return batch_data, label_data

我们现在可以初始化嵌入矩阵，声明占位符，并初始化嵌入查找函数。使用以下代码执行此操作：

embeddings = tf.Variable(tf.random_uniform([vocabulary_size,  
    embedding_size], -1.0, 1.0)) 
# Create data/target placeholders 
x_inputs = tf.placeholder(tf.int32, shape=[batch_size]) 
y_target = tf.placeholder(tf.int32, shape=[batch_size, 1]) 
valid_dataset = tf.constant(valid_examples, dtype=tf.int32) 
# Lookup the word embedding: 
embed = tf.nn.embedding_lookup(embeddings, x_inputs)

损失函数应该是诸如softmax之类的东西，它计算预测错误单词类别时的损失。但由于我们的目标有 10,000 个不同的类别，因此非常稀疏。这种稀疏性导致关于模型的拟合或收敛的问题。为了解决这个问题，我们将使用称为噪声对比误差的损失函数。这种 NCE 损失函数通过预测单词类与随机噪声预测将我们的问题转化为二元预测。num_sampled参数指定批量变成随机噪声的程度：

nce_weights = tf.Variable(tf.truncated_normal([vocabulary_size,  
    embedding_size], stddev=1.0 / np.sqrt(embedding_size))) 
nce_biases = tf.Variable(tf.zeros([vocabulary_size]))
loss = tf.reduce_mean(tf.nn.nce_loss(weights=nce_weights, 
                                     biases=nce_biases, 
                                     inputs=embed, 
                                     labels=y_target, 
                                     num_sampled=num_sampled, 
                                     num_classes=vocabulary_size))

现在我们需要创建一种方法来查找附近的单词到我们的验证单词。我们将通过计算验证集和所有单词嵌入之间的余弦相似性来完成此操作，然后我们可以为每个验证字打印出最接近的单词集。使用以下代码执行此操作：

norm = tf.sqrt(tf.reduce_sum(tf.square(embeddings), 1, keepdims=True)) 
normalized_embeddings = embeddings / norm 
valid_embeddings = tf.nn.embedding_lookup(normalized_embeddings, valid_dataset) 
similarity = tf.matmul(valid_embeddings, normalized_embeddings, transpose_b=True)

我们现在声明我们的优化函数并初始化我们的模型变量：

optimizer = tf.train.GradientDescentOptimizer(learning_rate=1.0).minimize(loss) 
init = tf.global_variables_initializer() 
sess.run(init)

现在我们可以训练我们的嵌入并在训练期间打印损失和最接近我们验证集的单词。使用以下代码执行此操作：

loss_vec = [] 
loss_x_vec = [] 
for i in range(generations): 
    batch_inputs, batch_labels = generate_batch_data(text_data, batch_size, window_size) 
    feed_dict = {x_inputs : batch_inputs, y_target : batch_labels} 
    # Run the train step 
    sess.run(optimizer, feed_dict=feed_dict) 
    # Return the loss 
    if (i+1) % print_loss_every == 0: 
        loss_val = sess.run(loss, feed_dict=feed_dict) 
        loss_vec.append(loss_val) 
        loss_x_vec.append(i+1) 
        print("Loss at step {} : {}".format(i+1, loss_val)) 
    # Validation: Print some random words and top 5 related words 
    if (i+1) % print_valid_every == 0: 
        sim = sess.run(similarity, feed_dict=feed_dict) 
        for j in range(len(valid_words)): 
            valid_word = word_dictionary_rev[valid_examples[j]] 
            top_k = 5 # number of nearest neighbors 
            nearest = (-sim[j, :]).argsort()[1:top_k+1] 
            log_str = "Nearest to {}:".format(valid_word) 
            for k in range(top_k): 
                close_word = word_dictionary_rev[nearest[k]] 
                log_str = "%s %s," % (log_str, close_word) 
            print(log_str)

在前面的代码中，我们在调用argsort方法之前采用相似矩阵的否定。我们这样做是因为我们想要找到从最高相似度值到最低相似度值的索引，而不是相反。

这产生以下输出：

Loss at step 500 : 13.387781143188477 
Loss at step 1000 : 7.240757465362549 
Loss at step 49500 : 0.9395825862884521 
Loss at step 50000 : 0.30323168635368347 
Nearest to cliche: walk, intrigue, brim, eileen, dumber, 
Nearest to love: plight, fiction, complete, lady, bartleby, 
Nearest to hate: style, throws, players, fearlessness, astringent, 
Nearest to silly: delivers, meow, regain, nicely, anger, 
Nearest to sad: dizzying, variety, existing, environment, tunney,

工作原理

我们通过Skip-Gram方法在电影评论数据集上训练了一个 word2vec 模型。我们下载了数据，将单词转换为带有字典的索引，并将这些索引号用作嵌入查找，我们对其进行了训练，以便附近的单词可以相互预测。

乍一看，我们可能期望验证集的附近单词集合是同义词。事实并非如此，因为很少有同义词实际上在句子中彼此相邻。我们真正得到的是预测我们的数据集中哪些单词彼此接近。我们希望使用这样的嵌入将使预测更容易。

为了使用这些嵌入，我们必须使它们可重用并保存它们。我们将通过实现 CBOW 嵌入在下一个秘籍中执行此操作。

使用 CBOW 嵌入

在这个秘籍中，我们将实现 word2vec 的 CBOW（连续词袋）方法。它与Skip-Gram方法非常相似，除了我们预测来自环境词周围窗口的单个目标词。

准备

在这个秘籍中，我们将实现 word2vec 的CBOW方法。它与Skip-Gram方法非常相似，只是我们预测来自环境词周围窗口的单个目标词。

在前面的示例中，我们将窗口和目标的每个组合视为一组配对的输入和输出，但是使用 CBOW，我们将周围的窗口嵌入添加到一起以获得一个嵌入来预测目标字嵌入：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nlbw1Y9X-1681566911069)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/tf-ml-cookbook-2e-zh/img/5e2d25dc-7309-4f36-bb6a-b192653c4c62.png)]

图 5：如何在一个例子的窗口上创建 CBOW 嵌入数据的描述（每侧窗口大小为 1）

大多数代码都保持不变，除了我们需要改变我们创建嵌入的方式以及如何从句子生成数据。

为了使代码更易于阅读，我们已将所有主要函数移动到同一目录中名为text_helpers.py的单独文件中。此函数保存数据加载，文本正则化，字典创建和批量生成函数。除非另有说明，否则这些函数与使用 Skip-Gram 嵌入秘籍中显示的完全相同。

操作步骤

我们将按如下方式处理秘籍：

我们将首先加载必要的库，包括前面提到的text_helpers.py脚本，我们将把我们的函数用于文本加载和操作。然后我们将开始一个图会话：

import tensorflow as tf 
import matplotlib.pyplot as plt 
import numpy as np 
import random 
import os 
import pickle 
import string 
import requests 
import collections 
import io 
import tarfile 
import urllib.request 
import text_helpers 
from nltk.corpus import stopwords 
sess = tf.Session()

我们要确保在开始保存之前存在临时数据和参数保存文件夹。使用以下代码检查：

# Make a saving directory if it doesn't exist 
data_folder_name = 'temp' 
if not os.path.exists(data_folder_name): 
    os.makedirs(data_folder_name)

然后我们将声明模型的参数，这与我们在上一个秘籍中对Skip-Gram方法所做的类似：

# Declare model parameters 
batch_size = 500 
embedding_size = 200 
vocabulary_size = 2000 
generations = 50000 
model_learning_rate = 0.001 
num_sampled = int(batch_size/2 
window_size = 3 
# Add checkpoints to training 
save_embeddings_every = 5000 
print_valid_every = 5000 
print_loss_every = 100 
# Declare stop words 
stops = stopwords.words('english') 
# We pick some test words. We are expecting synonyms to appear 
valid_words = ['love', 'hate', 'happy', 'sad', 'man', 'woman']

我们已将数据加载和文本正则化函数移动到我们在开始时导入的单独文件中，此文件在 Github 仓库和 Packt 仓库中都可用。现在我们可以打电话给他们我们也只想要包含三个或更多单词的评论。使用以下代码：

texts, target = text_helpers.load_movie_data(data_folder_name) texts = text_helpers.normalize_text(texts, stops) # Texts must contain at least 3 words target = [target[ix] for ix, x in enumerate(texts) if len(x.split()) > 2] texts = [x for x in texts if len(x.split()) > 2]

现在我们将创建我们的词汇词典，这将帮助我们查找单词。当我们想要打印出最接近我们验证集的单词时，我们还需要一个反向字典来查找索引中的单词：

word_dictionary = text_helpers.build_dictionary(texts,  
vocabulary_size) 
word_dictionary_rev = dict(zip(word_dictionary.values(), word_dictionary.keys())) 
text_data = text_helpers.text_to_numbers(texts, word_dictionary) 
# Get validation word keys 
valid_examples = [word_dictionary[x] for x in valid_words]

接下来，我们将初始化我们想要拟合的单词嵌入，并声明模型数据占位符。使用以下代码执行此操作：

embeddings = tf.Variable(tf.random_uniform([vocabulary_size, embedding_size], -1.0, 1.0)) 
# Create data/target placeholders 
x_inputs = tf.placeholder(tf.int32, shape=[batch_size,  
2*window_size]) 
y_target = tf.placeholder(tf.int32, shape=[batch_size, 1]) 
valid_dataset = tf.constant(valid_examples, dtype=tf.int32)

我们现在可以创建一种处理嵌入一词的方法。由于 CBOW 模型添加了上下文窗口的嵌入，我们将创建一个循环并将所有嵌入添加到窗口中：

# Lookup the word embeddings and 
# Add together window embeddings: 
embed = tf.zeros([batch_size, embedding_size]) 
for element in range(2*window_size): 
    embed += tf.nn.embedding_lookup(embeddings, x_inputs[:, element])

我们将使用 TensorFlow 中内置的噪声对比误差损失函数，因为我们的分类输出太稀疏，无法使 softmax 收敛，如下所示：

# NCE loss parameters 
nce_weights = tf.Variable(tf.truncated_normal([vocabulary_size,  
embedding_size], stddev=1.0 / np.sqrt(embedding_size))) 
nce_biases = tf.Variable(tf.zeros([vocabulary_size])) 
# Declare loss function (NCE) 
loss = tf.reduce_mean(tf.nn.nce_loss(weights=nce_weights, 
                                     biases=nce_biases, 
                                     inputs=embed, 
                                     labels=y_target, 
                                     num_sampled=num_sampled, 
                                     num_classes=vocabulary_size))

就像我们在 Skip-Gram 秘籍中所做的那样，我们将使用余弦相似性来打印离我们的验证字数据集最近的单词，以了解我们的嵌入如何工作。使用以下代码执行此操作：

norm = tf.sqrt(tf.reduce_sum(tf.square(embeddings), 1, keepdims=True)) 
normalized_embeddings = embeddings / norm 
valid_embeddings = tf.nn.embedding_lookup(normalized_embeddings, valid_dataset) 
similarity = tf.matmul(valid_embeddings, normalized_embeddings, transpose_b=True)

要保存嵌入，我们必须加载 TensorFlow train.Saver方法。这个方法默认保存整个图，但是我们可以给它一个参数来保存嵌入变量，我们也可以给它一个特定的名称。在这里，我们给它的名称与图中的变量名称相同：

saver = tf.train.Saver({"embeddings": embeddings})

我们现在将声明我们的优化函数并初始化我们的模型变量。使用以下代码执行此操作：

optimizer = tf.train.GradientDescentOptimizer(learning_rate=model_learning_rate).minimize(loss) 
init = tf.global_variables_initializer() 
sess.run(init)

最后，我们可以遍历我们的训练步骤，打印出损失，并将我们指定的嵌入和字典保存到：

loss_vec = [] 
loss_x_vec = [] 
for i in range(generations): 
    batch_inputs, batch_labels = text_helpers.generate_batch_data(text_data, batch_size, window_size, method='cbow') 
    feed_dict = {x_inputs : batch_inputs, y_target : batch_labels} 
    # Run the train step 
    sess.run(optimizer, feed_dict=feed_dict) 
    # Return the loss 
    if (i+1) % print_loss_every == 0: 
        loss_val = sess.run(loss, feed_dict=feed_dict) 
        loss_vec.append(loss_val) 
        loss_x_vec.append(i+1) 
        print('Loss at step {} : {}'.format(i+1, loss_val)) 
    # Validation: Print some random words and top 5 related words 
    if (i+1) % print_valid_every == 0: 
        sim = sess.run(similarity, feed_dict=feed_dict) 
        for j in range(len(valid_words)): 
            valid_word = word_dictionary_rev[valid_examples[j]] 
            top_k = 5 # number of nearest neighbors 
            nearest = (-sim[j, :]).argsort()[1:top_k+1] 
            log_str = "Nearest to {}:".format(valid_word) 
            for k in range(top_k): 
                close_word = word_dictionary_rev[nearest[k]] 
                print_str = '{} {},'.format(log_str, close_word) 
            print(print_str) 
    # Save dictionary + embeddings 
    if (i+1) % save_embeddings_every == 0: 
        # Save vocabulary dictionary 
        with open(os.path.join(data_folder_name,'movie_vocab.pkl'), 'wb') as f: 
            pickle.dump(word_dictionary, f) 
        # Save embeddings 
        model_checkpoint_path = os.path.join(os.getcwd(),data_folder_name,'cbow_movie_embeddings.ckpt') 
        save_path = saver.save(sess, model_checkpoint_path) 
        print('Model saved in file: {}'.format(save_path))

这产生以下输出：

Loss at step 100 : 62.04829025268555 
Loss at step 200 : 33.182334899902344
... 
Loss at step 49900 : 1.6794960498809814 
Loss at step 50000 : 1.5071022510528564 
Nearest to love: clarity, cult, cliched, literary, memory, 
Nearest to hate: bringing, gifted, almost, next, wish, 
Nearest to happy: ensemble, fall, courage, uneven, girls, 
Nearest to sad: santa, devoid, biopic, genuinely, becomes, 
Nearest to man: project, stands, none, soul, away, 
Nearest to woman: crush, even, x, team, ensemble, 
Model saved in file: .../temp/cbow_movie_embeddings.ckpt

text_helpers.py文件中除了一个函数之外的所有函数都具有直接来自上一个秘籍的函数。我们将通过添加cbow方法对generate_batch_data()函数稍加补充，如下所示：

elif method=='cbow': 
    batch_and_labels = [(x[:y] + x[(y+1):], x[y]) for x,y in zip(window_sequences, label_indices)] 
    # Only keep windows with consistent 2*window_size 
    batch_and_labels = [(x,y) for x,y in batch_and_labels if len(x)==2*window_size] 
    batch, labels = [list(x) for x in zip(*batch_and_labels)]

工作原理

此秘籍与使用 Skip-Gram 创建嵌入非常相似。主要区别在于我们如何生成数据并组合嵌入。

对于这个秘籍，我们加载数据，正则化文本，创建词汇词典，使用字典查找嵌入，组合嵌入，并训练神经网络来预测目标词。

值得注意的是，CBOW方法训练周围窗口的累加嵌入以预测目标字。这样做的一个结果是来自 word2vec 的CBOW方法具有Skip-Gram方法缺乏的平滑效果，并且认为这对于较小的文本数据集可能是优选的是合理的。

使用 word2vec 进行预测

在本文中，我们将使用先前学习的嵌入策略来执行分类。

准备

现在我们已经创建并保存了 CBOW 字嵌入，我们需要使用它们来对电影数据集进行情感预测。在本文中，我们将学习如何加载和使用预先训练的嵌入，并使用这些嵌入来通过训练逻辑线性模型来预测好的或坏的评论来执行情感分析。

情感分析是一项非常艰巨的任务，因为人类语言使得很难掌握所谓意义的真实含义的微妙之处和细微差别。讽刺，笑话和含糊不清的引用都使这项任务成倍增加。我们将在电影评论数据集上创建一个简单的逻辑回归，以查看我们是否可以从我们在上一个秘籍中创建并保存的 CBOW 嵌入中获取任何信息。由于本文的重点是加载和使用已保存的嵌入，我们不会追求更复杂的模型。

操作步骤

我们将按如下方式处理秘籍：

我们将首先加载必要的库并启动图会话：

import tensorflow as tf 
import matplotlib.pyplot as plt 
import numpy as np 
import random 
import os 
import pickle 
import string 
import requests 
import collections 
import io 
import tarfile 
import urllib.request 
import text_helpers 
from nltk.corpus import stopwords 
sess = tf.Session()

现在我们将声明模型参数。嵌入大小应与我们用于创建前面的 CBOW 嵌入的嵌入大小相同。使用以下代码执行此操作：

embedding_size = 200 
vocabulary_size = 2000 
batch_size = 100 
max_words = 100 
stops = stopwords.words('english')

我们将从我们创建的text_helpers.py文件加载和转换文本数据。使用以下代码执行此操作：

texts, target = text_helpers.load_movie_data() 
# Normalize text 
print('Normalizing Text Data') 
texts = text_helpers.normalize_text(texts, stops) 
# Texts must contain at least 3 words 
target = [target[ix] for ix, x in enumerate(texts) if len(x.split()) > 2] 
texts = [x for x in texts if len(x.split()) > 2] 
train_indices = np.random.choice(len(target), round(0.8*len(target)), replace=False) 
test_indices = np.array(list(set(range(len(target))) - set(train_indices))) 
texts_train = [x for ix, x in enumerate(texts) if ix in train_indices] 
texts_test = [x for ix, x in enumerate(texts) if ix in test_indices] 
target_train = np.array([x for ix, x in enumerate(target) if ix in train_indices]) 
target_test = np.array([x for ix, x in enumerate(target) if ix in test_indices])

我们现在加载我们在拟合 CBOW 嵌入时创建的单词字典。重要的是我们加载它以便我们具有从单词到嵌入索引的完全相同的映射，如下所示：

dict_file = os.path.join(data_folder_name, 'movie_vocab.pkl') 
word_dictionary = pickle.load(open(dict_file, 'rb'))

我们现在可以使用我们的单词字典将我们加载的句子数据转换为数字numpy数组：

text_data_train = np.array(text_helpers.text_to_numbers(texts_train, word_dictionary)) 
text_data_test = np.array(text_helpers.text_to_numbers(texts_test, word_dictionary))

由于电影评论的长度不同，我们将它们标准化，因此它们的长度都相同。在我们的例子中，我们将其设置为 100 个单词。如果评论少于 100 个单词，我们将用零填充它。使用以下代码执行此操作：

text_data_train = np.array([x[0:max_words] for x in [y+[0]*max_words for y in text_data_train]]) 
text_data_test = np.array([x[0:max_words] for x in [y+[0]*max_words for y in text_data_test]])

现在我们将声明我们的模型变量和占位符以进行逻辑回归。使用以下代码执行此操作：

A = tf.Variable(tf.random_normal(shape=[embedding_size,1])) 
b = tf.Variable(tf.random_normal(shape=[1,1])) 
# Initialize placeholders 
x_data = tf.placeholder(shape=[None, max_words], dtype=tf.int32) 
y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

为了让 TensorFlow 恢复我们预先训练的嵌入，我们必须首先给Saver方法一个变量来恢复，所以我们将创建一个嵌入变量，其形状与我们将加载的嵌入相同：

embeddings = tf.Variable(tf.random_uniform([vocabulary_size, embedding_size], -1.0, 1.0))

现在我们将embedding_lookup函数放在图上，并将句子中所有单词的平均嵌入。使用以下代码执行此操作：

embed = tf.nn.embedding_lookup(embeddings, x_data) 
# Take average of all word embeddings in documents 
embed_avg = tf.reduce_mean(embed, 1)

接下来，我们将声明我们的模型操作和损失函数，记住我们的损失函数已经内置了 sigmoid 操作，如下所示：

model_output = tf.add(tf.matmul(embed_avg, A), b) 
# Declare loss function (Cross Entropy loss) 
loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=model_output, labels=y_target))

现在我们将向图添加预测和精度函数，以便我们可以在使用以下代码训练模型时评估精度：

prediction = tf.round(tf.sigmoid(model_output)) 
predictions_correct = tf.cast(tf.equal(prediction, y_target), tf.float32) 
accuracy = tf.reduce_mean(predictions_correct)

我们将声明我们的优化函数并初始化以下模型变量：

my_opt = tf.train.AdagradOptimizer(0.005) 
train_step = my_opt.minimize(loss) 
init = tf.global_variables_initializer() 
sess.run(init)

现在我们有一个随机初始化嵌入，我们可以告诉Saver方法将我们之前的 CBOW 嵌入加载到嵌入变量中。使用以下代码执行此操作：

model_checkpoint_path = os.path.join(data_folder_name,'cbow_movie_embeddings.ckpt') 
saver = tf.train.Saver({"embeddings": embeddings}) 
saver.restore(sess, model_checkpoint_path)

现在我们可以开始训练几代。请注意，我们每 100 代就可以节省训练和测试损失和准确率。我们只会每 500 代打印一次模型状态，如下所示：

train_loss = [] 
test_loss = [] 
train_acc = [] 
test_acc = [] 
i_data = [] 
for i in range(10000): 
    rand_index = np.random.choice(text_data_train.shape[0], size=batch_size) 
    rand_x = text_data_train[rand_index] 
    rand_y = np.transpose([target_train[rand_index]]) 
    sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y}) 
    # Only record loss and accuracy every 100 generations 
    if (i+1)%100==0: 
        i_data.append(i+1) 
        train_loss_temp = sess.run(loss, feed_dict={x_data: rand_x, y_target: rand_y}) 
        train_loss.append(train_loss_temp) 
        test_loss_temp = sess.run(loss, feed_dict={x_data: text_data_test, y_target: np.transpose([target_test])}) 
        test_loss.append(test_loss_temp) 
        train_acc_temp = sess.run(accuracy, feed_dict={x_data: rand_x, y_target: rand_y}) 
        train_acc.append(train_acc_temp) 
        test_acc_temp = sess.run(accuracy, feed_dict={x_data: text_data_test, y_target: np.transpose([target_test])}) 
        test_acc.append(test_acc_temp) 
    if (i+1)%500==0: 
        acc_and_loss = [i+1, train_loss_temp, test_loss_temp, train_acc_temp, test_acc_temp] 
        acc_and_loss = [np.round(x,2) for x in acc_and_loss] 
        print('Generation # {}. Train Loss (Test Loss): {:.2f} ({:.2f}). Train Acc (Test Acc): {:.2f} ({:.2f})'.format(*acc_and_loss))

结果如下：

Generation # 500\. Train Loss (Test Loss): 0.70 (0.71). Train Acc (Test Acc): 0.52 (0.48) 
Generation # 1000\. Train Loss (Test Loss): 0.69 (0.72). Train Acc (Test Acc): 0.56 (0.47) 
... 
Generation # 9500\. Train Loss (Test Loss): 0.69 (0.70). Train Acc (Test Acc): 0.57 (0.55) 
Generation # 10000\. Train Loss (Test Loss): 0.70 (0.70). Train Acc (Test Acc): 0.59 (0.55)

TensorFlow 机器学习秘籍第二版：6~8（4）https://developer.aliyun.com/article/1426840

TensorFlow 机器学习秘籍第二版：6~8（3）

实现 TF-IDF

准备

操作步骤

工作原理

更多

使用 Skip-Gram 嵌入

准备

操作步骤

工作原理

更多

使用 CBOW 嵌入

准备

操作步骤

工作原理

更多

使用 word2vec 进行预测

准备

操作步骤

热门文章

最新文章

相关课程

相关电子书

相关实验场景