向量空间模型 2022-1-17_人工智能 向量空间模型

人工智能基础总目录

一 向量空间模型

1.1 向量空间模型

通过特征抽取器 feature extractor 将文本映射到向量。有深度神经网络后，可替换 feature extractor 和 features 部分，通过神经网络实现。

1.2 词、文档向量的表示

分词：中文无分割空格，英文不存该问题。

1 词频

2 归一化词频

3 二值化词频

有就是1， 没有为0.

4 TF-IDF

词频 ： 停用词 stop word : the 的 地 等，不计算其频率。
逆文本频率 idf： 考虑到有些词本身的出现概率比较高。
统计的方式实现， 不是通过训练求解 wi 的模型。

5 TextRank

可以获取语序的信息。 与PageRank 算法接近。

取窗口大小为5，取5个词的窗口，无向图，

具体方法

• 文本分割成若干组成单元（词\句子）
• 将每个单元作为图的结点
• 用单元之间的相似度作为边的权重
• 通过循环迭代计算句子的TextRank值
  

考虑词的关系和共现
• 本质是Co-occurrence矩阵的分解
• 形式上已经接近 Word2Vec, Graph Embedding

二 向量空间模型构建

2.1 共现矩阵

推荐系统中的说明

比如： 人买了什么东西，买了为1，没买为0， data 数据见下左图。apple 和 Banana 两次一起买过。一起买过的次数为右图。对称矩阵。可以拥有推荐，当我买apple ， 可以推荐买的最多的一个milk 作为推荐。

简单的根据购买行为来猜你喜欢，已知一群人的购买行为，计算得到共现矩阵，将别人的购买行为与共现矩阵相乘，将已经买过的商品设置为0，

import numpy as np
import pandas as pd

data = pd.DataFrame()
x = np.array(data)
y = np.array(data.T)
# 矩阵运算
co_matrix = np.dot(y, x)
# 将对角线设置为 0
np.fill_diagonal(co_matrix, 0)

import numpy as np
import pandas as pd

columns = ["Apple", "Banana", "Carrot", "Milk"]
names = ["a", "b", "d", "e", "f"]
data = pd.DataFrame([[1, 1, 1, 0], [1, 0, 0, 1], [0, 1, 1, 0], [1, 0, 1, 0], [0, 0, 1, 1]],
                    columns=columns,
                    index=["Ann", "Bob", "John", "Jane", "Susan"])
x = np.array(data)
y = np.array(data.T)
# 矩阵运算
co_matrix = np.dot(y, x)
# 将对角线设置为 0， 活动共现矩阵
np.fill_diagonal(co_matrix, 0)

user_buy_times = pd.DataFrame([[0, 0, 6, 6], [0, 4, 7, 0], [5, 0, 0, 6], [0, 5, 0, 8], [7, 5, 0, 0]],
                              columns=columns,
                              index=names)
user = np.array(user_buy_times)
user_matrix = np.dot(user, co_matrix)
# 非零元素的位置 结果说明： 值在各轴上的对应的位置
idx = np.nonzero(user)
# print(np.transpose(np.nonzero(a))) 打印位置
user_matrix[idx] = 0
# 获得推荐的数据
df2 = pd.DataFrame(user_matrix, columns=columns, index=names)

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

自然语言处理

• Word-by-Word （以句子级别或者窗口级别）
• Word-by-Document
  

2.2 词向量

词是承载语义得最基本单位 , 如何表示一个词？
用向量表征词汇的意思: 映射离散语义到欧式空间。

获取词向量示意

使用spacy 的库函数，获取单词对应的维度的向量情况。

import numpy as np
import spacy
from sklearn.decomposition import PCA


# 要想使用 Spacy 和 访问其不同的 properties， 需要先创建 pipelines。 通过加载 模型 来创建一个 pipeline。
nlp = spacy.load("en_core_web_md")
animals = "dog cat hamster lion tiger elephant cheetah monkey gorilla antelope rabbit mouse rat zoo home "
# 文档分解成句子，然后再tokenize 分词
animal_tokens = nlp(animals)

# Part of Speech Tagging (词性标注)
# word 的 动词/名词/… 属性
for word in animal_tokens:
   print(word.text, "$", word.tag_, "$", spacy.explain(word.tag_))
all_tags = {w.pos: w.pos_ for w in animal_tokens}


for token in animal_tokens:
    print(token.text, token.has_vector, token.vector_norm, token.is_oov)

# 获取词向量，内置GloVe， 是一种用于获取表示单词的向量的无监督学习算法
animal_vectors = np.vstack([word.vector for word in animal_tokens if word.has_vector])

# 每个Doc、Span和Token都有一个.similarity()方法，它允许您将其与另一个对象进行比较，并确定相似度
# 假定一个相当通用的相似性定义
animal_word = nlp("animal")
animal_word[0].similarity(animal_tokens[0])


# 将词向量用于主成分分析， 可用于降低维度画图
pca = PCA(n_components=2)
animal_vecs_transformed = pca.fit_transform(animal_vectors)
animal_vecs_transformed = np.c_[animals.split(), animal_vecs_transformed]
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

2.2.1 用处

1 逻辑运算

2 跨语言匹配

3 翻译

4 图像匹配和描述

5 泛化

比如： 白狗图片 - 白色向量 + 灰色向量 得到 灰狗图片， 比较理想的情况下。

2.2.2 词向量的获取方法

词向量的获取方法为 Skip-gram 和 CBOW。需要得到当前词最近的词。

1 Skip-gram

滑动窗口，用当前词预测周边词。神经网络训练结果。

2 CBOW

周边词预测当前词。神经网络训练结果。

三 距离计算

3.1 欧式距离

3.2 余弦距离

3.3 Jaccard

四 降维技术

4.1 PCA

PCA本质上是矩阵分解，对称阵可以表示为QAQ.t的形式，Q为正交阵，pca实际上是取最大的k个特征值及其对应的特征向量重新表示原矩阵（谱分解为一般矩阵分解svd的特殊形式）.

大部分的图像分解后可以做到原图想的模糊处理也跟渐进正态有关。

减少数据集的维数, 同时保留数据集中对方差贡献最大的特征, 主成分可以看作一个线性方程。线性降维技术。转换后的特征与原来的含义已经不同。

• 描述数据的主要特征是什么
• 互相独立的特征有哪些
• 消除特征之间的相关性

通用方法总结 :

• 计算协方差矩阵
• 计算特征值和特征向量
• 特征值从大到小排，选取对应的特征向量
• 原始数据 与 选取的特征向量相乘（投影），得到将维度后的数据。

4.2 T-SNE

二维显示高维向量的利器，非线性降维技术。
从SNE 来的， 使用SNE 默认使用高斯分布， T-SNE 使用 t分布。T 分布 解决异常点问题。

4.3 代码实践

利用PCA和T-SNE降维MNIST， MINIST 数据自行下载得到。

from __future__ import print_function
import time

from read_mnist import read_data_sets
import numpy as np
import pandas as pd
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
import seaborn as sns

# mnist_dir: 存放4个MNIST数据集压缩文件的文件夹
mnist_dir= r""
data = read_data_sets(mnist_dir)

X = data.train.images / 255
y = data.train.labels
print(X.shape, y.shape)
# (55000, 784) (55000,)

# 数据存放在df中
feat_cols = ["pixel" + str(i) for i in range(X.shape[1])]
df = pd.DataFrame(X, columns=feat_cols)
df["y"] = y
df["label"] = df["y"].apply(lambda i: str(i))

# 固定的随机选择15个数据并画图显示
np.random.seed(42)
rndperm = np.random.permutation(df.shape[0])
plt.gray()
fig = plt.figure(figsize=(16, 12))
for i in range(0, 15):
    ax = fig.add_subplot(3, 5, i + 1, title="Digit:{}".format(str(df.loc[rndperm[i], "label"])))
    ax.matshow(df.loc[rndperm[i], feat_cols].values.reshape((28, 28)).astype(float))
plt.show()

# 使用pca 降维
pca = PCA(n_components=3)
pca_result = pca.fit_transform(df[feat_cols].values)

df["pca_one"] = pca_result[:, 0]
df["pca_two"] = pca_result[:, 1]
df["pca_three"] = pca_result[:, 2]
print("Explained variation per principal componet: {}".format(pca.explained_variance_ratio_))

# 使用2个维度的可视化
plt.figure(figsize=(16, 10))
sns.scatterplot(
    x="pca_one", y="pca_two", hue="y", palette=sns.color_palette("hls", 10),
    data=df.loc[rndperm, :], legend="full", alpha=0.3
)

plt.show()

# 使用3个维度图形可视化
ax = plt.figure(figsize=(16, 10)).gca(projection="3d")
ax.scatter(
    xs=df.loc[rndperm, :]["pca_one"],
    ys=df.loc[rndperm, :]["pca_two"],
    zs=df.loc[rndperm, :]["pca_three"],
    c=df.loc[rndperm, :]["y"],
    cmap="tab10"
)
ax.set_xlabel("pca_one")
ax.set_ylabel("pca_two")
ax.set_zlabel("pca_three")
plt.show()

# 取1000 数据查看TSNE效果
N = 1000
data_subset = df.loc[rndperm[:N], :].copy()

# TSNE
time_start = time.time()
tsne = TSNE(n_components=2, verbose=1, perplexity=40, n_iter=300)
tsne_results = tsne.fit_transform(data_subset)
print("t-SNE done! Time elapsed: {} seconds".format(time.time() - time_start))

# 使用2个维度的可视化
data_subset["tsne-2d-one"] = tsne_results[:, 0]
data_subset["tsne-2d-two"] = tsne_results[:, 1]

plt.figure(figsize=(16, 10))
sns.scatterplot(
    x="tsne-2d-one", y="tsne-2d-two", hue="y", palette=sns.color_palette("hls", 10),
    data=data_subset, legend="full", alpha=0.3
)
plt.show()
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
78
79
80
81
82
83
84
85
86
87
88