MXNet 相关函数详解

本是古典何须时尚 2023-07-02 03:28 30阅读 0赞

# **norm()** #

norm()
    	1.Matlab函数中的 norm() 
    		1.应用：norm()用于计算矩阵范数
    		2.格式：n = norm(A);
    		      n = norm(A,p);
    		3.功能：norm函数可计算几种不同类型的矩阵范数,根据p的不同可得到不同的范数
    		4.如果A为矩阵
    			n=norm(A) 返回A的最大奇异值，即max(svd(A))
    　　			n=norm(A,p) 根据p的不同，返回不同的值
    		5.如果A为向量
    			norm(A,p) 返回向量A的p范数。即返回 sum(abs(A).^p)^(1/p),对任意 1<p<+∞.
    　　			norm(A) 返回向量A的2范数，即等价于norm(A,2)。
    　　			norm(A,inf) 返回max(abs(A))
    　　			norm(A,-inf) 返回min(abs(A))
    		6.p值、返回值
    			p值	返回值
    			1	返回A中最大一列和，即max(sum(abs(A)))
    			2	返回A的最大奇异值，和n=norm(A)用法一样
    			inf	返回A中最大一行和，即max(sum(abs(A’)))
    			'fro'	A和A‘的积的对角线和的平方根，即sqrt(sum(diag(A'*A)))
    
    	2.例子：
    		1.X.norm().asscalar() //asscalar函数将norm()求得的结果变换为Python中的标量
    		2.sum()：NDArray元素求和，结果中的数值虽为标量，但结果仍然为NDArray格式，可以通过norm().asscalar()函数转换为Python中的标量(实数)

![20200125190426636.png][]

3.对Python的控制流求导
    			对如下函数进行求导：
    				def f(a):
    					b = a * 2
    					while b.norm().asscalar() < 1000:
    						b = b * 2
    					if b.sum().asscalar() > 0:
    						c = b
    					else:
    						c = 100 * b
    					return c
    
    			函数f(a)最后的输出值c由输入值a决定，即c=xa，导数x=c/a。

![20200125190426555.png][]

--------------------

# **MXNet 基础入门** #

1.如何使用NDArray来处理数据
    	1.NDArray几种不同的创建方法
    		1.第1条：从mxnet中导入nd
    		2.第2条：使用arange()函数创建一个长度为12的行向量

![20200125190433264.png][]

该NDArray包含12个元素（element），其值为arange(12)指定的0-11。在打印的结果中标注了属性<NDArray 12 @cpu(0)>。
    			其中12指的是NDArray的形状，就是向量的长度。@cpu(0)表示默认情况下NDArray被创建在CPU上。
     
    		3.第3条：使用reshape()函数修改x的形状，将x修改为一个3行4列的矩阵

![2020012519043692.png][]

4.第4条：创建一个各元素为0，形状为(2,3,4)的张量。PS：矩阵和向量都是一种特殊的张量。

![20200125190453969.png][]

5.第5条：同理，创建一个各元素为1的张量。

![2020012519050232.png][]

6.第6条：通过Python的列表（list）指定NDArray中每个元素的值。

![20200125190517107.png][]

7.第7条：通过nd.random.normal()方法，随机生成NDArray每个元素的值，创建一个形状为(3,4)的NDArray。
    			每个元素随机采样于均值为0方差为1的正态分布。

![20200125190516188.png][]

8.第8条：通过shape属性获取形状，通过size属性获取NDArray中元素的个数。

![20200125190522138.png][]

2.NDArray的运算
    		1.第1条：按元素加法

![20200125190554641.png][]

2.第2条：按元素乘法

![2020012519060097.png][]

3.第3条：按元素除法

![20200125190609377.png][]

4.第4条：按元素指数运算，exp

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70][]

5.第5条：对矩阵b做转置，矩阵a、b做矩阵乘法操作，a为3行4列，b为4行3列，故其结果为一个3行3列的矩阵。dot

![20200125190731681.png][]

6.第6条：NDArray元素求和（结果为标量，但仍然为NDArray格式，可以通过norm().asscalar()函数转换为Python中的数），sum()

![20200125190703659.png][]

3.广播机制
    		上面提到的两个NDArray之间元素级的运算都是基于两个NDArray形状相同，如果两个NDArray形状不同，在运算的过程中会触发广播（broadcasting）机制，
    		即先把两个NDArray搞成形状相同，然后再进行运算。
    		广播（broadcasting）机制简单理解就是行与列间复制，达到不同NDArray之间形状相同的目的。

![20200125190703706.png][]

4.NDArray在进行运算的过程中产生的内存开销
    		1.第1条：每一个操作都会新开辟一块内存空间用来存储操作后的运算结果。

![20200125190655106.png][]

2.第2条：可以通过[:]将计算结果写入之前变量创建的内存空间中。nd.zeros_like(x)方法可以创建一个形状和x相同，但元素均为0的NDArray。

![20200125190709503.png][]

3.第3条：在第2条的运算中，虽然变量z在计算前后的内存地址相同，在本质上其运行原理仍然是先将x+y的值放到一个新开辟的内存空间中，
    			然后再将结果拷贝到z的内存中。
    			为了避免这种计算过程中的内存开销，可以使用运算符全名函数中的out参数解决该问题。

![20200125190710476.png][]

可以看到，前后的内存地址相同，这种开销也得以避免。
     
    		4.第4条：现有NDArray的值在之后的程序中不会复用，可以直接使用如下方法来减少内存开销。x+=y，x[:]=x+y

![20200125190752377.png][]

5.NDArray的索引
    		类比Python中列表（list）的索引，NDArray的索引可以理解为每一个元素的位置。索引的值从0开始逐渐递加。
    		举个栗子，一个3行2列的矩阵，其行索引为0,1,2，列索引为0,1。
    
    		1.第1条：创建一个3行3列的矩阵x，通过x[1:3]，根据Python的开闭原则，可知取的值为索引为1和2行的数据。

![20200125190800897.png][]

2.第2条：通过x[1,2]这种形式可以取出指定的元素，可以对其重新赋值。

![20200125190808281.png][]

3.第3条：可以通过[1:2,1:3]这种方式取出NDArray中的多个元素，可以对这些元素进行重新赋值。

![20200125190819749.png][]

6.NDArray与NumPy格式的相互转换
    		可以通过array()函数将numpy转换为ndarray，通过asnumpy()函数将ndarray转化为numpy。

![20200125190826827.png][]

7.小结
    		NDArray是MXNet中存储和转换数据的主要工具，可以将它理解为MXNet实现的一种数据结构。
    		在这一节中可以了解到如何对NDArray进行创建、运算、制定索引，同时与numpy格式进行转换的方法。
    
    
    2.简述MXNet提供的自动求导功能
    	1.很多深度学习框架需要编译计算图进行求导，而MXNet不需要，使用自带的autograd包即可实现自动求导功能。
    	2.下面来看两个例子。
    		1.第一个：对简单的数学函数进行求导
    			 对函数y=2x^2进行求导

![20200125190836182.png][]

其中涉及的细节有一点：
    				1.求变量x的导数，需要先调用x.attach_grad()函数创建需要的内存空间
    				2.为了减少计算和内存的开销，默认情况下，MXNet不会记录用于求倒数的计算图，
    				  我们需要需要调用autograd.record()函数来让MXNet记录有关的计算图。
    				3.通过y.backward()函数求倒数，其结果为x.grad
    
    		2.第二个：对Python的控制流求导
    			 对如下函数进行求导：
    				def f(a):
    					b = a * 2
    					while b.norm().asscalar() < 1000:
    						b = b * 2
    					if b.sum().asscalar() > 0:
    						c = b
    					else:
    						c = 100 * b
    					return c
    
    			函数f(a)最后的输出值c由输入值a决定，即c=xa，导数x=c/a。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 1][]

3.小结
    		通过MXNet自动求导总共分为3步：
    			1.开辟存储导数的内存空间a.attach_grad()
    			2.通过autograd.record()函数记录计算图，并实现相应的函数
    			3.调用c.backward()函数进行求导
    
    
    
    3.如何通过ndarray和autograd实现简单的线性回归
    	线性回归是监督学习中的一种，是一个最简单，也是最有用的单层神经网络。
    	我的理解是这样的给定一些数据集X，根据训练好的模型（将数据集X带入模型中），都有一个特定的y值与其对应。训练这个模型就是我们需要做的工作。
    	那线性回归就是y=ax+b，我们要做的就是确定斜率a和位移b的值。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 2][]

1.第1步：数据集的创建
    		在工业级的生产环境中，数据集往往来源于真事的业务场景（在Web日志中挖掘攻击行为呀，预测房价啊一类的），这里是演示，所以暂且使用随机生成的数据。
    		在第一个例子中，作者使用了一套人工生成的数据，相应的生成公式如下：y[i] = 2*X[i][0] - 3.4*X[i][1] + 4.2 + noise
    		noise服从均值为0方差为0.1的正态分布。
    		相应的代码如下：
    				>>> from mxnet import ndarray as nd
    				>>> from mxnet import autograd
    				>>> num_inputs = 2
    				>>> num_examples = 1000
    				>>> true_w = [2,-3.4]
    				>>> true_b = 4.2
    				>>> X = nd.random_normal(shape=(num_example,num_inputs))
    				Traceback (most recent call last):
    				  File "<stdin>", line 1, in <module>
    				NameError: name 'num_example' is not defined
    				>>> X = nd.random_normal(shape=(num_examples,num_inputs))
    				>>> y = true_w[0]*X[:,0]+true_w[1]*X[:,1]+true_b
    				>>> y += .01*nd.random_normal(shape=y.shape)

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 3][]

2.第2步：数据读取
    		当我们拥有了一定的数据集之后，我们要做的就是数据的读取。不断的读取这些数据块，进行神经网络的训练。
    		相应的函数如下：
    				>>> def date_iter():
    				...     idx = list(range(num_examples))
    				...     random.shuffle(idx)
    				...     for i in range(0,num_examples,batch_size):
    				...         j = nd.array(idx[i:min(i+batch_size,num_examples)])
    				...         yield nd.take(X,j),nd.take(y,j)

![2020012519091417.png][]

通过yield关键字来构造成迭代器，依次取出不同的样本数据（10个）。
    		通过for loop不断的遍历将迭代器中的数据取出。
    				>>> for date,label in adte_iter():
    				...     print(date,label)
    				...     break
     		接下来将读取到的数据，传入我们给定的算法中进行训练。
    
    	3.第3步：定义模型
    		先来随机初始化模型的参数。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 4][]

创建参数的梯度：

![2020012519093449.png][]

参数初始化完成后我们就可以进行模型的定义：
    			>>> def net(X):
    			...     return nd.dot(X,w)+b
    
    	4.第4步：定义损失函数
    		通过损失函数衡量预测目标与真实目标之间的差距。
    		def square_loss(yhat,y):
        			return (yhat - y.reshape(yhat.shape))**2
    
    	5.第5步：优化
    		使用梯度下降进行求解。
    			def SGD(params,lr):
    				for param in params:
    					param[:] = param - lr * param.grad
    
    	6.第6步：训练
    				>>> epochs = 5
    				>>> learning_rate = .001
    				>>> 
    				>>> for e in range(epochs):
    				...     total_loss = 0
    				...     for data,label in adte_iter():
    				...         with autograd.record():
    				...             output = net(data)
    				...             loss = square_loss(output,label)
    				...         loss.backward()
    				...         SGD(params,learning_rate)
    				...         total_loss += nd.sum(loss).asscalar()
    				...     print("%d,loss: %f" % (e,total_loss/num_examples))
    				... 
    				0,loss: 0.130911
    				1,loss: 0.002628
    				2,loss: 0.000150
    				3,loss: 0.000102
    				4,loss: 0.000101
     
    			查看训练结果（和我们的预期相同）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 5][]![202001251909457.png][]

4.使用gluon的线性回归
    	1.第1步：数据集的创建

2.第2步：数据读取

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 6][]

3.第3步：定义模型

![20200125191007102.png][]

4.第4步：定义损失函数

![20200125191023693.png][]

5.第5步：优化

![20200125191022539.png][]

6.第6步：训练

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 7][]

5.总结
    	1.确认需要训练的数据集（特征工程）
    	2.将特征工程后的数据读取至内存中
    	3.定义模型同时初始化模型参数
    	4.定义损失函数、优化算法
    	5.训练模型及验证结果

--------------------

# **topk** #

1.mxnet官方文档topk函数介绍：http://mxnet.incubator.apache.org/api/python/docs/api/ndarray/ndarray.html?highlight=topk#mxnet.ndarray.topk
    2.mxnet.ndarray.topk(data=None, axis=_Null, k=_Null, ret_typ=_Null, is_ascend=_Null, dtype=_Null, out=None, name=None, **kwargs) 
    	1.topk：返回输入数组data中沿给定轴axis的顶部k个元素。返回的元素将被排序。
    	  返回值：out函数的输出
    	  返回类型：NDArray或NDArrays列表
    	2.传入参数 data：输入数组
    	3.传入参数 axis
    		（int或无，可选，缺省值为-1）选择指定轴上的顶部前k个索引。如果没有给定，则展平数组。默认值为-1，即最后一个轴。
    	4.传入参数 k
    		（int，可选，缺省值＝1）要选择的顶部元素的数量应该总是小于或等于给定轴中的元素编号。如果设置k<1，则执行全局排序。
    	5.传入参数 ret_typ
    		（{'both'，'indices'，'mask'，'value'}，可选，默认为'indices'）–返回类型。
    		“value”表示返回前k个值，“indices”表示返回前k个值的索引，“mask”表示返回包含0和1的掩码数组，1表示最大k值。
    		“both”意味着返回前k个元素的值和索引的列表。
    	6.传入参数 is_ascend
    		（布尔型，可选，默认值为0）–选择k个最大元素还是k个最小元素。
    		如果设置为false(默认为is_ascend=0)，将选择最大的前k个元素。
    		如果设置is_ascend=1，将选择最小的前k个元素。
    	7.传入参数 dtype
    		（{'float16'，'float32'，'float64'，'int32'，'int64'，'uint8'}，可选，默认值为'float32'）
    		ret_typ为“indices”或“both”时输出索引的数据类型。如果选定的数据类型不能精确表示索引，则会引发错误。
    	8.传入参数 out：（ndarray，可选）保存结果的输出ndarray。
     
    3.例子
    	x = [[ 0.3,  0.2,  0.4],
         	     [ 0.1,  0.3,  0.2]]
    	
    	#返回最后一个轴上最大元素的索引值
    	topk(x) = [[ 2.],
               	  [ 1.]]
    
    	#返回最后一个轴上的Top2即前两个最大值的元素值，'value'返回类型表示返回元素值
    	topk(x, ret_typ='value', k=2) = [[ 0.4,  0.3],
                                              [ 0.3,  0.2]]
    
    	#返回最后一个轴上的Top2即前两个最小值的的元素值，'value'返回类型表示返回元素值
    	topk(x, ret_typ='value', k=2, is_ascend=1) = [[ 0.2 ,  0.3],
                                                           [ 0.1 ,  0.2]]
    
    	#返回轴axis为0上的Top2即前两个最大值的元素值，'value'返回类型表示返回元素值
    	topk(x, axis=0, ret_typ='value', k=2) = [[ 0.3,  0.3,  0.4],
                                             	     [ 0.1,  0.2,  0.2]]
    
    	#'both''返回类型表示返回“包含前k个元素的值和对应的索引的”列表
    	topk(x, ret_typ='both', k=2) = [[[ 0.4,  0.3], [ 0.3,  0.2]] ,  [[ 2.,  0.], [ 1.,  2.]]]

--------------------

# **gluon NLP 预训练词嵌入** #

1.官方文档：https://gluon-nlp.mxnet.io/examples/word_embedding/word_embedding.html
    2.Counter词典、idx_to_token数组、token_to_idx词典
    	#使用Counter词典容器封装分词数据，key为分词，value为该分词出现的次数
    	counter = collections.Counter([tk for st in raw_dataset for tk in st])
    	#只保留在数据集中至少出现5次的词
    	counter = dict(filter(lambda x: x[1] >= 5, counter.items()))
    
    	#将词映射到整数索引
    	#数组：由索引和索引对应的元素值所组成
    	idx_to_token = [tk for tk, _ in counter.items()] 
    	#词典：key为数组idx_to_token中索引对应的元素值，value为数组idx_to_token中元素值对应的索引
    	token_to_idx = {tk: idx for idx, tk in enumerate(idx_to_token)}
    
    3.vocab词汇表、Counter词典、idx_to_token数组、token_to_idx词典
    	from mxnet.contrib import text
    	counter = collections.Counter([tk for st in tokenized_data for tk in st])
    	#创建Vocab词汇表：传入Counter词典进行初始化，该Vocab词汇表对象同时包含了idx_to_token数组和token_to_idx词典
    	#idx_to_token数组：元素值为分词，每个分词对应其索引位置
    	#token_to_idx词典：key为idx_to_token数组中的分词，value为分词在idx_to_token数组中的对应的索引位置
    	#min_freq：设置可过滤掉出现次数少于5的分词，即Counter词典中的value小于5的键值对都不会存储到Vocab词汇表中
    	vocab = text.vocab.Vocabulary(counter, min_freq=5)
    
    	#通过截断或者补0来将每条评论长度固定成500
    	def pad(x):
    		#将每条评论通过截断或者补0，使得每条评论长度变成500
    		return x[:500] if len(x) > 500 else x + [0] * (500 - len(x))
    		
    	#对每条评论进行分词，然后通过词典vocab的to_indices函数把分词转换成词索引
    	features = nd.array([pad(vocab.to_indices(x)) for x in tokenized_data])
    
    4.vocab词汇表、Counter词典、idx_to_token数组、token_to_idx词典
    	import warnings
    	warnings.filterwarnings('ignore')
    	from mxnet import gluon
    	from mxnet import nd
    	import gluonnlp as nlp
    	import re
    
    	#原文
    	text = " hello world \n hello nice world \n hi world \n"
    	 
    	#token_delim记号分隔符(单词分隔符)	seq_delim序号分隔符(句子分隔符)
    	def simple_tokenize(source_str, token_delim=' ', seq_delim='\n'):
    		#re.split(' ' + '|' + '\n', " hello world \n hello nice world \n hi world \n")
    		#split的结果：['', 'hello', 'world', '', '', 'hello', 'nice', 'world', '', '', 'hi', 'world', '', '']
    		#filter的结果：['hello', 'world', 'hello', 'nice', 'world', 'hi', 'world']
    		return filter(None, re.split(token_delim + '|' + seq_delim, source_str))
    
    	#Counter词典容器：key为分词，value为分词出现的次数
    	#Counter({'world': 3, 'hello': 2, 'nice': 1, 'hi': 1})
    	counter = nlp.data.count_tokens(simple_tokenize(text))
    
    	#创建Vocab词汇表：传入Counter词典进行初始化，该Vocab词汇表对象同时包含了idx_to_token数组和token_to_idx词典
    	#idx_to_token数组：元素值为分词，每个分词对应其索引位置
    	#token_to_idx词典：key为idx_to_token数组中的分词，value为分词在idx_to_token数组中的对应的索引位置
    	#Vocab(size=8, unk="<unk>", reserved="['<pad>', '<bos>', '<eos>']")
    	vocab = nlp.Vocab(counter)
    	#vocab词汇表中包含4个特殊的未知标记，然后还包含4个分词
    	len(vocab) #8
    	#vocab中的idx_to_token：为数组，由索引和索引对应的元素值所组成，将词映射到整数索引
    	#创建的vocab词汇表包含四个不同的单词和一个特殊的未知标记
    	for word in vocab.idx_to_token:
    		print(word)
    	"""
    	<unk>
    	<pad>
    	<bos>
    	<eos>
    	world
    	hello
    	hi
    	nice
    	"""
    
    	#词典：key为数组idx_to_token中索引对应的元素值，value为数组idx_to_token中元素值对应的索引
    	print(vocab.token_to_idx["<unk>"])	#0
    	print(vocab.token_to_idx["world"])	#4
    
    5.vocab词汇表、Counter词典、idx_to_token数组、token_to_idx词典
    	#查看要使用的fasttext算法中预训练的单词嵌入源数据(需要联网下载)，可以调用text.embedding.list_sources查看
    	nlp.embedding.list_sources('fasttext')[:5] #['crawl-300d-2M', 'crawl-300d-2M-subword', 'wiki.aa', 'wiki.ab', 'wiki.ace']
    	#创建fasttext算法的词嵌入层（需要联网下载'wiki.simple'源数据）
    	fasttext_simple = nlp.embedding.create('fasttext', source='wiki.simple')
    	#给Vocab词汇表中的词嵌入层添加'wiki.simple'源数据
    	vocab.set_embedding(fasttext_simple)
    	 
    	#默认情况下，vocab词汇表中未知的不存在的分词的向量都是零向量。它的长度等于FastText单词嵌入的向量维数：(300，)
    	#查看单词“beautiful”在vocab词汇表中的嵌入形状，但是单词“beautiful”实际不存在于vocab词汇表中
    	vocab.embedding['beautiful'].shape
    	#任何vocab词汇表中未知的不存在的分词的向量的前五个元素都是零。
    	vocab.embedding['beautiful'][:5]
    	#[0. 0. 0. 0. 0.]
    	#<NDArray 5 @cpu(0)>
    	#vocab词汇表中包含4个特殊的未知标记，然后还包含4个分词
    	len(vocab) #8
    
    	#单词“hello”和“world”在vocab中的嵌入形状
    	vocab.embedding['hello', 'world'].shape #(2, 300)
    	#嵌入“hello”和“world”的前五个元素，它们是非零的
    	vocab.embedding['hello', 'world'][:, :5]
    	#[[ 0.39567   0.21454  -0.035389 -0.24299  -0.095645]
    	# [ 0.10444  -0.10858   0.27212   0.13299  -0.33165 ]]
    	#<NDArray 2x5 @cpu(0)>
    
    	#单词'hello', 'world'在vocab词汇表中的索引位置
    	vocab['hello', 'world'] #[5, 4]
    	#vocab['分词1', '分词2'] 等同于 vocab.to_indices(['分词1', '分词2']) 同时获取多个分词在vocab词汇表中的索引位置
    	vocab.to_indices(['hello', 'world'])#[5, 4]
     
    	#我们可以通过指定单词“hello”和“world”的索引(5和4)和权重或嵌入矩阵来获得向量，
    	#这是在gluon.nn.Embedding中调用vocab.embedding.idx_to_vec得到的。
    	#我们初始化一个新层并使用layer.weight.set_data方法设置权重。
    	#随后，我们从权重向量中提取索引5和4，并检查它们的前五个条目。
    	input_dim, output_dim = vocab.embedding.idx_to_vec.shape
    	layer = gluon.nn.Embedding(input_dim, output_dim)
    	layer.initialize()
    	layer.weight.set_data(vocab.embedding.idx_to_vec)
    	layer(nd.array([5, 4]))[:, :5]
    	#根据索引(5和4)得到单词“hello”和“world”在嵌入矩阵中的权重向量
    	#[[ 0.39567   0.21454  -0.035389 -0.24299  -0.095645]
    	# [ 0.10444  -0.10858   0.27212   0.13299  -0.33165 ]]
    	#<NDArray 2x5 @cpu(0)>
    
    6.vocab词汇表、Counter词典、idx_to_token数组、token_to_idx词典
    	#查看要使用的glove算法中预训练的单词嵌入源数据(需要联网下载)，可以调用text.embedding.list_sources查看
    	nlp.embedding.list_sources('glove')[:5] #['glove.42B.300d', 'glove.6B.100d', 'glove.6B.200d', 'glove.6B.300d', 'glove.6B.50d']
    	#创建glove的词嵌入层（需要联网下载'glove.6B.50d'源数据）
    	glove_6b50d = nlp.embedding.create('glove', source='glove.6B.50d')
    
    	#1.使用Counter词典容器封装glove_6b50d数据集中idx_to_token数组中分词数据，Counter的key为idx_to_token数组中的分词，value为该分词出现的次数
    	#2.创建Vocab词汇表：传入Counter词典进行初始化，该Vocab词汇表对象同时包含了idx_to_token数组和token_to_idx词典
    	#  idx_to_token数组：元素值为分词，每个分词对应其索引位置
    	#  token_to_idx词典：key为idx_to_token数组中的分词，value为分词在idx_to_token数组中的对应的索引位置
    	vocab = nlp.Vocab(nlp.data.Counter(glove_6b50d.idx_to_token))
    	#给Vocab词汇表中的词嵌入层添加'glove.6B.50d'源数据
    	vocab.set_embedding(glove_6b50d)
    	#vocab词汇表中包含4个特殊的未知标记，然后还包含400000个分词
    	#vocab词汇表：同时包含了idx_to_token数组和token_to_idx词典
    	len(vocab)	#400004
    	len(vocab.idx_to_token)	#400004
    	len(vocab.token_to_idx)	#00004
    	#Vocab词汇表中的前4个为特殊的未知标记，后面才是分词
    	print(vocab.idx_to_token[:7]) #['<unk>', '<pad>', '<bos>', '<eos>', '!', '!!', '!!!']
    	#vocab词汇表：同时包含了idx_to_token数组和token_to_idx词典
    	#vocab['分词'] 等同于 vocab.token_to_idx['分词']，均为把分词作为key从vocab词汇表中的token_to_idx词典获取value值(分词在idx_to_token数组中的索引位置)
    	print(vocab['beautiful']) #71424
    	print(vocab.token_to_idx['beautiful']) #71424
    	print(vocab['fuck']) #154765
    	#vocab['分词1', '分词2'] 等同于 vocab.to_indices(['分词1', '分词2']) 同时获取多个分词在vocab词汇表中的索引位置
    	vocab.to_indices(['beautiful', 'fuck']) #[71424, 154765]
    	#vocab.idx_to_token[索引值]：根据索引从vocab词汇表中的idx_to_token数组获取分词
    	print(vocab.idx_to_token[71424]) #beautiful
    	#vocab.idx_to_token[索引值] 等同于 vocab.to_tokens(索引值)
    	vocab.to_tokens(71424) #'beautiful'
    	#vocab.embedding['分词']：获取该分词在词嵌入层中的权重矩阵
    	print(vocab.embedding['beautiful'])
    	#[ 0.54623    1.2042    -1.1288    -0.1325     0.95529    0.040524
    	# -0.47863   -0.3397    -0.28056    0.71761   -0.53691   -0.0045698
    	#  0.73217    0.12101    0.28093   -0.088097   0.59733    0.55264
    	#  0.056646  -0.50247   -0.63204    1.1439    -0.31053    0.1263
    	#  1.3155    -0.52444   -1.5041     1.158      0.68795   -0.85051
    	#  2.3236    -0.41789    0.44519   -0.019216   0.28969    0.53258
    	# -0.023008   0.58958   -0.72397   -0.85216   -0.17761    0.14432
    	#  0.40658   -0.52003    0.09081    0.082961  -0.021975  -1.6214
    	#  0.34579   -0.010919 ]
    	#<NDArray 50 @cpu(0)>
    
    7.余弦相似性cos算法
    	#为了应用单词嵌入，我们需要定义余弦相似度。余弦相似性决定了两个向量之间的相似性，即两个分词的相似度。
    	from mxnet import nd
    	#传入两个分词的权重矩阵，然后根据余弦相似性cos算法计算两个分词的相似值
    	def cos_sim(x, y):
    		return nd.dot(x, y) / (nd.norm(x) * nd.norm(y))
    
    	#两个向量之间的余弦相似度范围可以在-1和1之间。值越大，两个向量之间的相似性就越大。
    
    	x = nd.array([1, 2])
    	y = nd.array([10, 20])
    	z = nd.array([-1, -2])
    
    	print(cos_sim(x, y))
    	#[1.]
    	#<NDArray 1 @cpu(0)>
    	print(cos_sim(x, z))
    	#[-1.]
    	#<NDArray 1 @cpu(0)>
    
    8.求近义词
    	#求近义词
    	#根据提供的一个词获取其对应意思相近的词，即求近义词
    	#给定一个输入词，我们可以通过相似度从词汇表（400000个词，不包括4个未知标记）中找到最接近的前k个词。
    	#任何一对词之间的相似度可以用向量的余弦相似度cos算法来表示。
    	#我们首先必须规范化每一行，然后整个词汇表的嵌入矩阵和单个单词的嵌入矩阵做点积运算。
    	#然后我们可以找到点积最大的索引（topk），它恰好是最相似单词的索引。
    
    	#为了应用单词嵌入，我们需要定义余弦相似度。余弦相似性决定了两个向量之间的相似性，即两个分词的相似度。
    	from mxnet import nd
    	#传入两个分词的权重矩阵，然后根据余弦相似性cos算法计算两个分词的相似值
    	def cos_sim(x, y):
    		return nd.dot(x, y) / (nd.norm(x) * nd.norm(y))
    	 
    	def norm_vecs_by_row(x):
    		#规范化vocab词汇表中词嵌入层中的权重矩阵的每一行
    		return x / nd.sqrt(nd.sum(x * x, axis=1) + 1E-10).reshape((-1,1))
    
    	#传入参数：vocab词汇表对象，取前k最相近的单词，word根据查找的单词
    	def get_knn(vocab, k, word):
    		#获取该分词在词嵌入层中的权重矩阵
    		word_vec = vocab.embedding[word].reshape((-1, 1))
    		#vocab.embedding.idx_to_vec.shape的维度大小为 (400004, 50)，代表了400004个单词(包括4个未知标记)，每个单词有50个权重值
    		#规范化vocab词汇表中词嵌入层中的权重矩阵的每一行
    		vocab_vecs = norm_vecs_by_row(vocab.embedding.idx_to_vec)
    		#整个词汇表的嵌入矩阵和单个单词的嵌入矩阵做点积运算
    		dot_prod = nd.dot(vocab_vecs, word_vec)
    		#topk：从点积运算后的结果矩阵中取出前k个单词的权重矩阵
    		#ret_typ='indices'表示返回的实际是这些前k个单词的权重矩阵所在结果矩阵中的索引位置，并封装为列表最后返回
    		indices = nd.topk(dot_prod.reshape((len(vocab), )), k=k+1, ret_typ='indices')
    		indices = [int(i.asscalar()) for i in indices]
    		#移除第一个未知输入标记
    		#vocab.idx_to_token[索引值] 等同于 vocab.to_tokens(索引值)，根据前k个单词的权重矩阵对应的索引位置从idx_to_token数组中取出该单词
    		return vocab.to_tokens(indices[1:])
    		
    
    	get_knn(vocab, 5, 'baby')
    	#['babies', 'boy', 'girl', 'newborn', 'pregnant']
    	get_knn(vocab, 5, 'computers')
    	#['computer', 'phones', 'pcs', 'machines', 'devices']
    	get_knn(vocab, 5, 'run')
    	#['running', 'runs', 'went', 'start', 'ran']
    	get_knn(vocab, 5, 'beautiful')
    	#['lovely', 'gorgeous', 'wonderful', 'charming', 'beauty']
    
    	#vocab.embedding['分词']：获取该分词在词嵌入层中的权重矩阵
    	#根据余弦相似性cos算法计算两个分词的权重矩阵的相似值
    	cos_sim(vocab.embedding['baby'], vocab.embedding['babies'])
    	#[0.83871305]
    	#<NDArray 1 @cpu(0)>
    
    9.求类比词
    	#求类比词
    	#我们还可以将预训练的单词嵌入应用到单词类比问题中。例如，“男:女::子:女”就是一个比喻。
    	#这句话也可以理解为“男人对女人就像儿子对女儿一样”。
    	#单词类比完成问题具体定义为：对于类比“a:b::c:d”，给定前三个单词“a”、“b”、“c”，找到“d”。
    	#其思想是根据 vec(‘c’) + (vec(‘b’) - vec(‘a’)) 找到最相似的词向量。
    	#在本例中，我们将从vocab中的400000个索引单词中找到类似的单词。
    
    	def norm_vecs_by_row(x):
    		#规范化vocab词汇表中词嵌入层中的权重矩阵的每一行
    		return x / nd.sqrt(nd.sum(x * x, axis=1) + 1E-10).reshape((-1,1))
    		
    	#传入参数：vocab词汇表对象，取前k最相近的单词，word1/word2/word3根据查找的单词
    	def get_top_k_by_analogy(vocab, k, word1, word2, word3):
    		#获取word1/word2/word3分词在词嵌入层中的权重矩阵
    		word_vecs = vocab.embedding[word1, word2, word3]
    		#根据 vec(‘c’) + (vec(‘b’) - vec(‘a’)) 找到最相似的词向量
    		word_diff = (word_vecs[1] - word_vecs[0] + word_vecs[2]).reshape((-1, 1))
    		#规范化vocab词汇表中词嵌入层中的权重矩阵的每一行
    		vocab_vecs = norm_vecs_by_row(vocab.embedding.idx_to_vec)
    		#整个词汇表的嵌入矩阵和包含多个单词的嵌入矩阵做点积运算
    		dot_prod = nd.dot(vocab_vecs, word_diff)
    		#topk：从点积运算后的结果矩阵中取出前k个单词的权重矩阵
    		#ret_typ='indices'表示返回的实际是这些前k个单词的权重矩阵所在结果矩阵中的索引位置，并封装为列表最后返回
    		indices = nd.topk(dot_prod.reshape((len(vocab), )), k=k, ret_typ='indices')
    		indices = [int(i.asscalar()) for i in indices]
    		#vocab.idx_to_token[索引值] 等同于 vocab.to_tokens(索引值)，根据前k个单词的权重矩阵对应的索引位置从idx_to_token数组中取出该单词
    		return vocab.to_tokens(indices)
    
    	#为了应用单词嵌入，我们需要定义余弦相似度。余弦相似性决定了两个向量之间的相似性，即两个分词的相似度。
    	from mxnet import nd
    	#传入两个分词的权重矩阵，然后根据余弦相似性cos算法计算两个分词的相似值
    	def cos_sim(x, y):
    		return nd.dot(x, y) / (nd.norm(x) * nd.norm(y))
    		
    	def cos_sim_word_analogy(vocab, word1, word2, word3, word4):
    		words = [word1, word2, word3, word4]
    		vecs = vocab.embedding[words]
    		#根据 vec(‘c’) + (vec(‘b’) - vec(‘a’)) 计算出的词向量和指定类比单词的权重矩阵进行余弦相似性cos计算相似值
    		return cos_sim(vecs[1] - vecs[0] + vecs[2], vecs[3])
    
    	#根据 vec(‘c’) + (vec(‘b’) - vec(‘a’)) 计算出的词向量和指定类比单词的权重矩阵进行余弦相似性cos计算相似值
    	cos_sim_word_analogy(vocab, 'man', 'woman', 'son', 'daughter')
    	#[0.9658341]
    	#<NDArray 1 @cpu(0)>
    
    	get_top_k_by_analogy(vocab, 1, 'man', 'woman', 'son')
    	#['daughter']
    	get_top_k_by_analogy(vocab, 1, 'beijing', 'china', 'tokyo')
    	#['japan']
    	get_top_k_by_analogy(vocab, 1, 'bad', 'worst', 'big')
    	#['biggest']
    	get_top_k_by_analogy(vocab, 1, 'do', 'did', 'go')
    	#['went']

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 8][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 9][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 10][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 11][]

[20200125190426636.png]: https://img-blog.csdnimg.cn/20200125190426636.png
[20200125190426555.png]: https://img-blog.csdnimg.cn/20200125190426555.png
[20200125190433264.png]: https://img-blog.csdnimg.cn/20200125190433264.png
[2020012519043692.png]: https://img-blog.csdnimg.cn/2020012519043692.png
[20200125190453969.png]: https://img-blog.csdnimg.cn/20200125190453969.png
[2020012519050232.png]: https://img-blog.csdnimg.cn/2020012519050232.png
[20200125190517107.png]: https://img-blog.csdnimg.cn/20200125190517107.png
[20200125190516188.png]: https://img-blog.csdnimg.cn/20200125190516188.png
[20200125190522138.png]: https://img-blog.csdnimg.cn/20200125190522138.png
[20200125190554641.png]: https://img-blog.csdnimg.cn/20200125190554641.png
[2020012519060097.png]: https://img-blog.csdnimg.cn/2020012519060097.png
[20200125190609377.png]: https://img-blog.csdnimg.cn/20200125190609377.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200125190730843.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[20200125190731681.png]: https://img-blog.csdnimg.cn/20200125190731681.png
[20200125190703659.png]: https://img-blog.csdnimg.cn/20200125190703659.png
[20200125190703706.png]: https://img-blog.csdnimg.cn/20200125190703706.png
[20200125190655106.png]: https://img-blog.csdnimg.cn/20200125190655106.png
[20200125190709503.png]: https://img-blog.csdnimg.cn/20200125190709503.png
[20200125190710476.png]: https://img-blog.csdnimg.cn/20200125190710476.png
[20200125190752377.png]: https://img-blog.csdnimg.cn/20200125190752377.png
[20200125190800897.png]: https://img-blog.csdnimg.cn/20200125190800897.png
[20200125190808281.png]: https://img-blog.csdnimg.cn/20200125190808281.png
[20200125190819749.png]: https://img-blog.csdnimg.cn/20200125190819749.png
[20200125190826827.png]: https://img-blog.csdnimg.cn/20200125190826827.png
[20200125190836182.png]: https://img-blog.csdnimg.cn/20200125190836182.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200125190844336.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200125190855348.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200125190905589.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[2020012519091417.png]: https://img-blog.csdnimg.cn/2020012519091417.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200125190922353.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[2020012519093449.png]: https://img-blog.csdnimg.cn/2020012519093449.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200125190937254.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[202001251909457.png]: https://img-blog.csdnimg.cn/202001251909457.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200125191015667.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[20200125191007102.png]: https://img-blog.csdnimg.cn/20200125191007102.png
[20200125191023693.png]: https://img-blog.csdnimg.cn/20200125191023693.png
[20200125191022539.png]: https://img-blog.csdnimg.cn/20200125191022539.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200125191039931.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200125191206446.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/2020012519121810.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20200125191223740.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20200125191230166.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9henVzYS5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70