精华内容
下载资源
问答
  • 向量表示

    2019-07-05 14:11:38
    N-gram词向量表示和语言模型 Co-currence矩阵的行(列)向量作为词向量 ❖ 分布式连续表示 Co-currence矩阵的SVD降维的低维词向量表示 Word2Vec: Continuous Bag of Words Model Word2Vec: Skip-Gr...

    分类

    离散表示

    • One-hot representation, Bag Of Words Unigram语言模型
    • N-gram词向量表示和语言模型
    • Co-currence矩阵的行(列)向量作为词向量

    分布式连续表示

    • Co-currence矩阵的SVD降维的低维词向量表示
    • Word2Vec: Continuous Bag of Words Model
    • Word2Vec: Skip-Gram Model

    优缺点

    离散表示的问题:
    1> 无法衡量词向量之间的关系
    2> 词表维度随着语料库增长膨胀
    3> n-gram词序列随语料库膨胀更快
    4> 数据稀疏问题

    I. 离散表示

    1. one-hot表示

    1)设立语料库
    John likes to watch movies. Mary likes too.
    John also likes to watch football games.
    2)根据语料库构建的词典
    {“John”: 1, “likes”: 2, “to”: 3, “watch”: 4, “movies”: 5, “also”: 6, “football”: 7, “games”: 8, “Mary”: 9, “too”: 10}
    3) 把上面词典中词按照One-hot表示
    John: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    likes: [0, 1, 0, 0, 0, 0, 0, 0, 0, 0]


    too : [0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
    注意
    ❖ 词典包含10个单词,每个单词有唯一索引
    ❖ 在词典中的顺序和在句子中的顺序没有关联

    2. 词袋模型(Bag of Words)

    1)文档的向量表示可以直接将各词的词向量表示加和
    John likes to watch movies. Mary likes too. => [1, 2, 1, 1, 1, 0, 0, 0, 1, 1]
    John also likes to watch football games. => [1, 1, 1, 1, 0, 1, 1, 1, 0, 0]
    2)计算词权重 TF-IDF
    Bi-gram和N-gram
    词袋模型的问题:未考虑词的顺序

    3. Co-currence共现矩阵的行(列)向量作为词向量

    共现矩阵的目的
    Word - Document 的共现矩阵主要用于发现主题(topic),用于
    主题模型,如LSA (Latent Semantic Analysis)
    共现矩阵存在的问题
    • 向量维数随着词典大小线性增长
    • 存储整个词典的空间消耗非常大
    • 一些模型如文本分类模型会面临稀疏性问题
    • 模型会欠稳定
    解决方案
    构造低维稠密向量作为词的分布式表示 (25~1000维)!

    II. 分布式连续表示

    分布式表示可以降低表达的复杂度,节省空间。
    在这里插入图片描述

    Co-currence矩阵的SVD降维的低维词向量表示

    为了解决上面提到的共现矩阵维度太高的问题,最直接的想法就是通过SVD对共现矩阵向量进行降维。但它同样存在很多问题:

    • 计算量随语料库和词典增长膨胀太快,对X(n,n)维 的矩阵,计算量O(n^3)。 而对大型的语料库, n-400K,语料库大小1~60B
      token
    • 因为词库字典被定死了,难以为词典中新加入的词分配词向量
    • 与其他深度学习模型框架差异大
    Word2Vec: Continuous Bag of Words Model

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    Word2Vec: Skip-Gram Model

    在这里插入图片描述

    word2vec的缺点
    • 对每个local context window单独训练,没有利用包 含在global co-currence矩阵中的统计信息
    • 对多义词无法很好的表示和处理,因为使用了唯一 的词向量

    本文内容根据七月学堂课件内容整理而成

    展开全文
  • 向量表示和句向量、文章向量计算方法 本文介绍一种计算句向量和文章向量的方法及参考代码,自然语言处理的第一步即是要进行文本的向量化,包括获得词向量,句向量或者文章向量,以便输入各种机器学习模型或者深度...

    本文介绍一种计算句向量和文章向量的方法及参考代码,自然语言处理的第一步即是要进行文本的向量化,包括获得词向量,句向量或者文章向量,以便输入各种机器学习模型或者深度学习模型。

    词向量

    可以笼统的认为词向量是文本向量的基本单位,句向量、文章向量都可以由构成文章的词向量转化计算得到。
    关于词的表示,比如one-hot编码,词袋模型,分布式编码等等。相关资料有很多,此处引用相关资料:

    1 词的独热表示:One-hot Representation
    采用稀疏方式 存储,简单易实现
    灯泡:[0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0]、灯管:[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0]
    维度过大词汇鸿沟现象:任意两个词之间都是孤立的。光从这两个向量中看不出两个词是否有关系,哪怕”灯泡”和”灯管”这两个词是同义词也不行
    2 词袋模型: 类似用词频等表示,比如tf-idf或textrank计算的权重来表示词,不会考虑单词的语义及它们在文档中的顺序
    3 词的分布式表示:Distributed representation
    传统的独热表示( one-hot representation)仅仅将词符号化,不包含任何语义信息
    Distributed representation 最早由 Hinton在 1986 年提出。它是一种低维实数向量,这种向量一般长成这个样子: [0.792, −0.177, −0.107, 0.109, −0.542, …]
    最大的贡献就是让相关或者相似的词,在距离上更接近了

    句向量和文章向量计算方法

    方法1:前面提到的词袋模型方式,可以用tf-idf直接生成句向量或文章向量

    代码示例:直接用sklearn的TfidfVectorizer工具来获得所需向量

    from sklearn.feature_extraction.text import TfidfVectorizer
    vectorizer = TfidfVectorizer()
    # cutWordList是文章分词后得到的列表,tf_matrix即是得到的文章或者句子的向量
    tf_matrix = vectorizer.fit_transform(cutWordList).toarray()
    

    实际上是文章的每个词,计算得到tf-idf值,然后放到一个array里得到的向量,由此也可以用词的textrank权值,统一按由大到小的顺序放在一个array得到一篇文章的向量

    方法2 根据前面提到的词嵌入模式得到词向量

    基于词向量的固定表征:word2vec、fastText、glove。 基于词向量的动态表征:elmo、GPT、bert。
    动态词向量相较于静态词向量,更加充分利用了上下文信息,所以可以解决一词多义的问题。在工程实践上其优越性也得到了证明(BERT 在多个 NLP 任务中也表现优异)。参考阅读:[embedding 技术实践总结]。(https://zhuanlan.zhihu.com/p/143763320)这块我的理解是网络在训练的时候,随机初始化词向量,然后将词向量作为网络参数来进行训练,故此成为动态词向量

    可以用一些开源的静态词向量如glove训练的中文词向量来做,如下是一份预训练词向量文件预览:
    在这里插入图片描述
    实际是训练好的几万个常用词的词向量,这样一个文本文件。项目中直接加载进来使用即可。
    代码示例:
    如下是对词向量文件进行读取,获取词的词向量以便使用

    def get_embeddings_index(embeddings_model_file):
        dir_path = os.path.dirname(os.path.abspath(__file__))
        #dir_path = os.path.dirname(dir_path)
        local_path = os.path.join(dir_path, embeddings_model_file)
        word_embeddings = {}
        count = 0
        with open(local_path, encoding='utf-8') as f:
            for line in f:
                count += 1
                if count > 1:
                    values = line.split()
                    word = values[0]
                    try:
                        embedding = np.asarray(values[1:], dtype=np.float64)
                    except BaseException as e:
                        #print(e)
                        embedding = np.asarray(values[2:], dtype=np.float64)
                    word_embeddings[word] = embedding
                else:
                    print('词向量信息:%s' % line)
        return word_embeddings
    

    接着就可以用词向量来构建句向量或者文章向量了,此处以句向量的构建为例

    def get_sentence_vector(words_list,embedding_dim=300):
        '''
        获取内容的向量
        :param sentence: 句子
        :param embedding_dim:  向量维度
        :return: 一个句子的特征维度
        '''
        global embeddings_index
    
        #embeddings_index = get_all_sentences_vector_mul.embeddings_index
    
        sent_matrix = np.zeros((len(words_list), embedding_dim),dtype = np.float64) #初始化空矩阵
    
        for i in range(len(words_list)):
            if words_list[i]:
                embedding_vector = embeddings_index.get(words_list[i])
                if embedding_vector is not None and len(embedding_vector)>=embedding_dim: #使用的词向量库 有的词长短不一致
                    if embedding_vector.shape != embedding_dim:
                         sent_matrix[i] = embedding_vector
        #字向量构造句向量,向量点乘,然后取范数,先是构造1x8的全1矩阵,与8x300的向量做点积,相当于每个词向量中对应元素相加(300列,每列一个词向量的浮点值),即词向量叠加组成句向量,除以该句向量的模,做个单位化
        d =  np.dot(np.ones((1,len(words_list)),dtype = np.float64),sent_matrix)
        norm= np.linalg.norm(d, axis=1, keepdims=True)   # 向量的2范数,相当于向量的莫
        vector = d/norm   #向量除以向量模,相当于单位化
        return vector[0]
    

    得到句向量之后就可以进行各种操作了,比如进行聚类或者进行相似度计算

    文章余弦相似度计算示例

    可以直接看代码示例:一个计算余弦相似度的接口,传入两个句向量或者文章向量后,计算返回两个句子或者两篇文章的余弦相似度值。

    def cos_sim(vector_a, vector_b):
        """
        计算两个向量之间的余弦相似度
        :param vector_a: 向量 a
        :param vector_b: 向量 b
        :return: sim
        """
        vector_a = np.mat(vector_a)
        vector_b = np.mat(vector_b)
        num = float(vector_a * vector_b.T)
        denom = np.linalg.norm(vector_a) * np.linalg.norm(vector_b)
        sim = num / denom
        return sim
    
    

    其他

    一些深度学习模型进行文本分类或者其他NLP任务如摘要提取,通常是动态计算文章向量,比如用bert+rnn等进行文本分类,因为Bert等模型对输入格式有要求,所以需要特殊处理来得到相应向量,输入模型。

    展开全文
  • 文本的向量表示

    2020-07-07 17:14:29
    文本的向量表示 1. 为什么需要文本的表示? 文字是人类认知过程中产生的高层认知抽象实体,我们需要将其转换为数字向量或矩阵作为机器学习算法模型以及神经网络模型的标准输入输出。 2. 词袋模型(Bag-of-words) ...

    文本的向量表示

    1. 为什么需要文本的表示?

    文字是人类认知过程中产生的高层认知抽象实体,我们需要将其转换为数字向量或矩阵作为机器学习算法模型以及神经网络模型的标准输入输出。

    2. 词袋模型(Bag-of-words)

    Bag-of-words模型是信息检索领域常用的文档表示方法。在文本特征生成过程中,对于一个文档,词袋模型忽略其单词顺序和语法、句法等要素,将其仅仅看作是若干个词汇的集合,文档中每个单词的出现都是独立的,不依赖于其它单词是否出现。也就是说,文档中任意一个位置出现的任何单词,都不受该文档语意影响而独立选择的。主要方法包括one-hot编码、tf-idf、n-gram模型

    2.1 One-hot 编码

    2.1.1 对于单词的one-hot表示

    假设给定一个词典为 [今天, 天气, 真好,他们,去,爬山]。该词典可以看作一个容量为6的词袋,每个单词的表示为:
    今天: [1, 0, 0, 0, 0, 0]
    天气: [0, 1, 0, 0, 0, 0]
    真好: [0, 0, 1, 0, 0, 0]

    爬山: [0, 0, 0, 0, 0, 1]

    在one-hot表示中,每个单词的向量长度为词袋的容量(假设词袋有10000个单词,某单词的向量长度为10000)。并且该单词在词袋中的对应位置为1,其余位置为0。 python中sklearn可以生成:

    import numpy as np
    from sklearn import preprocessing
    words = np.array(["今天", "天气", "真好","他们","去","爬山"])  # 词袋
    words=words.reshape((6,1))  # 转化成6,1矩阵
    
    enc = preprocessing.OneHotEncoder()
    enc.fit(words)  
    enc.categories_   # fit之后内部会改变顺序 用词语句查看
    # [array(['今天', '他们', '去', '天气', '爬山', '真好'], dtype='<U2')]
    
    result = enc.transform([["天气"]]).toarray()   # 天气 对应的向量
    # array([[0., 0., 0., 1., 0., 0.]])
    

    2.1.2 对于句子的one-hot表示

    给定三个句子**“小明 今天 爬山”“小红 昨天 跑步”“小红 今天 又 爬山 又 跑步”**。首先根据这些句子构造词袋(可以用分词、去重)为 **[小明 小红 爬山 跑步 又 今天 昨天]。**各句子的向量表示为:
    “小明 今天 爬山”:[1, 0, 1, 0, 0, 1, 0]
    “小红 昨天 跑步”:[0, 1, 0, 1, 0, 0, 1]
    “小红 今天 又 爬山 又 跑步”:[0, 1, 1, 1, 1, 1, 0]
    每个句子中所有单词都会出现在词袋中,其向量长度为词袋的容量。以“小明 今天 爬山”为例,“小明”出现在词袋中,在词袋对应位置设为1。“今天”出现在词袋中第6个位置,对应位置为1。“爬山”出现在词袋中第3个位置,对应位置为1。其余位置为0。由于第三句中“又”出现两次,其向量也可以表示为 [0, 1, 1, 2, 1, 1, 0]。
    当“小红 今天 又 爬山 又 跑步”表示为 [0, 1, 1, 2, 1, 1, 0] 时,其中“又”出现的频率为2,一般会认为其比较重要,但是从实际而言,“又”的重要性比不上“爬山”、“跑步”等频率为1的单词。所以,并不是出现的次数越多越重要、并不是出现的越少就越不重要。由此可以引出 tf-idf。

    2.2 n-gram模型

    n-gram模型为了保持词的顺序,做了一个滑窗的操作,这里的n表示的就是滑窗的大小,例如2-gram模型,也就是把2个词当做一组来处理,然后向后移动一个词的长度,再次组成另一组词,把这些生成一个字典,按照词袋模型的方式进行编码得到结果。该模型考虑了词一定范围内的关联性。
    假设给定句子:
    John likes to watch movies. Mary likes too.
    John also likes to watch football games.
    以上两句可以构造一个词典,{"John likes”: 1, "likes to”: 2, "to watch”: 3, "watch movies”: 4, "Mary likes”: 5, "likes too”: 6, "John also”: 7, "also likes”: 8, “watch football”: 9, “football games”: 10}
    那么第一句的向量表示为:[1, 1, 1, 1, 1, 1, 0, 0, 0, 0],其中第一个1表示John likes在该句中出现了1次,依次类推。
    缺点: 随着n的大小增加,词表会成指数型膨胀,会越来越大。

    2.3 tf-idf

    TF-IDF(term frequency–inverse document frequency,词频-逆向文件频率)是一种用于信息检索(information retrieval)与文本挖掘(text mining)的常用加权技术。
    TF-IDF是一种统计方法,用以评估字词对于一个文件集或一个语料库中的其中一份文件的重要程度字词的重要性随着它在文件中出现的次数成正比增加,但同时会随着它在语料库中出现的频率成反比下降。
    TF-IDF的主要思想是:如果某个单词在一篇文章中出现的频率TF高,并且在其他文章中很少出现,则认为此词或者短语具有很好的类别区分能力,适合用来分类。

    (1)TF(Term Frequency)词频

    **词频(TF)表示词条(关键词)在一个文本中出现的频率。**计算公式为:
    tfi,j=ni,jknk,jt{f_{i,j}} = \frac{{{n_{i,j}}}}{{\sum\nolimits_k {{n_{k,j}}} }}
    其中ni,jn_{i,j}表示单词tit_{i}在文档djd_{j}中的出现次数,分母表示文档djd_{j}中所有单词出现的次数之和。通俗理解为:
    tfw=wt{f_{w}} = \frac{{{某文档中单词w出现的次数}}}{{ {{该文档中所有单词数}} }}

    (2)IDF(Inverse Document Frequency)逆向文档频率

    逆向文件频率 (IDF) :某一特定词语的IDF,可以由总文件数目除以包含该词语的文件的数目再将得到的商取对数得到。如果包含单词tit_{i}的文档越少, IDF越大,则说明词条具有很好的类别区分能力。计算公式为:
    idfi=logD{j:tidj}id{f_i} = \log \frac{{|D|}}{{|\{ j:{t_i} \in {d_j}\} |}}
    其中D|D|表示所有文档数,分母表示包含单词tit_{i}的所有文档数。通俗理解为(加1防止分母为0):
    idfw=w+1idf_w = \frac{{{语料库总文档数}}}{{ {{包含单词w的总文档数+1}} }}

    (3)TF-IDF实际是TF*IDF

                                                        $tf-idf_w = tf_w*idf_w$
    

    对IDF的理解:语料库的文档总数实际上是一个词分布的可能性大小,n篇文档,有n种可能。包含词tit_{i}的文档数m,表示词tit_{i}的真实分布有m个“可能”。那么log(n/m) = log(n) - log(m)就可以表示词tit_{i}在m篇文档中的出现,导致的词tit_{i}分布可能性的减少(即信息增益),这个值越小,表示词tit_{i}分布越散,我们认为一个词越集中出现在某一类文档,它对这类文档的分类越有贡献,那么当一个词分布太散了,那他对文档归类的作用也不那么大了。

    举例

    给定3篇文档 ,“今天 上 NLP 课程”,“今天 的 课程 有 意思”,“数据 课程 也 有 意思”。词袋为**[今天 上 NLP 课程 的 有 意思 数据 也]**,容量为9。以第一句为例,“今天”的tf-idf值为14log32\frac{1}{4}\log \frac{3}{2};“上”的tf-idf值为14log31\frac{1}{4}\log \frac{3}{1};“NLP”的tf-idf值为14log31\frac{1}{4}\log \frac{3}{1},“课程”的tf-idf值为14log33\frac{1}{4}\log \frac{3}{3}
    则“今天 上 NLP 课程”的向量可以表示为[14log32\frac{1}{4}\log \frac{3}{2}14log31\frac{1}{4}\log \frac{3}{1}14log31\frac{1}{4}\log \frac{3}{1}14log33\frac{1}{4}\log \frac{3}{3},0, 0, 0, 0, 0]。以此类推,各句子可以表示为:

    “今天 上 NLP 课程”:[14log32\frac{1}{4}\log \frac{3}{2}14log31\frac{1}{4}\log \frac{3}{1}14log31\frac{1}{4}\log \frac{3}{1}14log33\frac{1}{4}\log \frac{3}{3},0, 0, 0, 0, 0]

    “今天 的 课程 有 意思”:[14log32\frac{1}{4}\log \frac{3}{2},0,0,14log33\frac{1}{4}\log \frac{3}{3}14log31\frac{1}{4}\log \frac{3}{1}, 14log32\frac{1}{4}\log \frac{3}{2}, 14log32\frac{1}{4}\log \frac{3}{2}, 0, 0]

    “数据 课程 也 有 意思”:[0,0,0,14log33\frac{1}{4}\log \frac{3}{3},0,14log32\frac{1}{4}\log \frac{3}{2}, 14log32\frac{1}{4}\log \frac{3}{2}, 14log31\frac{1}{4}\log \frac{3}{1}, 14log31\frac{1}{4}\log \frac{3}{1}]

    (4)利用sklearn库实现tf-idf

    from sklearn.feature_extraction.text import CountVectorizer
    from sklearn.feature_extraction.text import TfidfTransformer
     
    x_train = ['TF-IDF 主要 思想 是','算法 一个 重要 特点 可以 脱离 语料库 背景',
               '如果 一个 网页 被 很多 其他 网页 链接 说明 网页 重要']
    x_test=['原始 文本 进行 标记','主要 思想']
     
    #该类会将文本中的词语转换为词频矩阵,矩阵元素a[i][j] 表示j词在i类文本下的词频
    vectorizer = CountVectorizer(max_features=10)
    #该类会统计每个词语的tf-idf权值
    tf_idf_transformer = TfidfTransformer()
    #将文本转为词频矩阵并计算tf-idf
    tf_idf = tf_idf_transformer.fit_transform(vectorizer.fit_transform(x_train))
    #将tf-idf矩阵抽取出来,元素a[i][j]表示j词在i类文本中的tf-idf权重
    x_train_weight = tf_idf.toarray()
     
    #对测试集进行tf-idf权重计算
    tf_idf = tf_idf_transformer.transform(vectorizer.transform(x_test))
    x_test_weight = tf_idf.toarray()  # 测试集TF-IDF权重矩阵
     
    print('输出x_train文本向量:')
    print(x_train_weight)
    print('输出x_test文本向量:')
    print(x_test_weight)
    
    输出x_train文本向量:
    [[0.70710678 0.         0.70710678 0.         0.         0.
      0.         0.         0.         0.        ]
     [0.         0.3349067  0.         0.44036207 0.         0.44036207
      0.44036207 0.44036207 0.         0.3349067 ]
     [0.         0.22769009 0.         0.         0.89815533 0.
      0.         0.         0.29938511 0.22769009]]
    输出x_test文本向量:
    [[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
     [0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]]
    

    (5)自己实现tf-idf

    # -*- coding: utf-8 -*-
    from collections import defaultdict
    import math
    import operator
     
    """
    函数说明:创建数据样本
    Returns:
        dataset - 实验样本切分的词条
        classVec - 类别标签向量
    """
    def loadDataSet():
        dataset = [ ['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],    # 切分的词条
                       ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
                       ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
                       ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
                       ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
                       ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid'] ]
        classVec = [0, 1, 0, 1, 0, 1]  # 类别标签向量,1代表好,0代表不好
        return dataset, classVec
     
     
    """
    函数说明:特征选择TF-IDF算法
    Parameters:
         list_words:词列表
    Returns:
         dict_feature_select:特征选择词字典
    """
    def feature_select(list_words):
        #总词频统计
        doc_frequency=defaultdict(int)
        for word_list in list_words:
            for i in word_list:
                doc_frequency[i]+=1
     
        #计算每个词的TF值
        word_tf={}  #存储没个词的tf值
        for i in doc_frequency:
            word_tf[i]=doc_frequency[i]/sum(doc_frequency.values())
     
        #计算每个词的IDF值
        doc_num=len(list_words)
        word_idf={} #存储每个词的idf值
        word_doc=defaultdict(int) #存储包含该词的文档数
        for i in doc_frequency:
            for j in list_words:
                if i in j:
                    word_doc[i]+=1
        for i in doc_frequency:
            word_idf[i]=math.log(doc_num/(word_doc[i]+1))
     
        #计算每个词的TF*IDF的值
        word_tf_idf={}
        for i in doc_frequency:
            word_tf_idf[i]=word_tf[i]*word_idf[i]
     
        # 对字典按值由大到小排序
        dict_feature_select=sorted(word_tf_idf.items(),key=operator.itemgetter(1),reverse=True)
        return dict_feature_select
     
    if __name__=='__main__':
        data_list,label_list=loadDataSet() #加载数据
        features=feature_select(data_list) #所有词的TF-IDF值
        print(features)
        print("词袋容量:",len(features))
    
        
     # 结果:
    [('to', 0.0322394037469742), ('stop', 0.0322394037469742),
     ('worthless', 0.0322394037469742),
     ('my', 0.028288263356383563), ('dog', 0.028288263356383563), 
     ('him', 0.028288263356383563), ('stupid', 0.028288263356383563),
     ('has', 0.025549122992281622), ('flea', 0.025549122992281622), 
     ('problems', 0.025549122992281622), ('help', 0.025549122992281622),
     ('please', 0.025549122992281622), ('maybe', 0.025549122992281622),
     ('not', 0.025549122992281622), ('take', 0.025549122992281622), 
     ('park', 0.025549122992281622), ('dalmation', 0.025549122992281622), 
     ('is', 0.025549122992281622), ('so', 0.025549122992281622), 
     ('cute', 0.025549122992281622), ('I', 0.025549122992281622), 
     ('love', 0.025549122992281622), ('posting', 0.025549122992281622), 
     ('garbage', 0.025549122992281622), ('mr', 0.025549122992281622),
     ('licks', 0.025549122992281622), ('ate', 0.025549122992281622), 
     ('steak', 0.025549122992281622), ('how', 0.025549122992281622), 
     ('quit', 0.025549122992281622), ('buying', 0.025549122992281622), 
     ('food', 0.025549122992281622)]
    词袋容量: 32
    

    (6)tf-idf的不足

    TF-IDF算法实现简单快速,但是仍有许多不足之处:
    (1)没有考虑特征词的位置因素对文本的区分度,词条出现在文档的不同位置时,对区分度的贡献大小是不一样的。
    (2)按照传统TF-IDF,往往一些生僻词的IDF(反文档频率)会比较高、因此这些生僻词常会被误认为是文档关键词。
    (3)传统TF-IDF中的IDF部分只考虑了特征词与它出现的文本数之间的关系,而忽略了特征项在一个类别中不同的类别间的分布情况。
    (4)对于文档中出现次数较少的重要人名、地名信息提取效果不佳。

    展开全文
  • NLP ——句向量表示

    2020-09-30 11:13:38
    NLP ——句向量表示 基于Word2vec (1) (2) 基于GloVe GloVe词向量模型融合了全局矩阵分解方法(Matrix Factorization)和局部文本框捕捉方法(word2vec),是一种用于获得单词矢量表示的无监督学习算法。 ...

    NLP ——句向量表示

    • 基于Word2vec
      (1) 在这里插入图片描述
      (2)
      在这里插入图片描述
    • 基于GloVe
      GloVe词向量模型融合了全局矩阵分解方法(Matrix Factorization)和局部文本框捕捉方法(word2vec),是一种用于获得单词矢量表示的无监督学习算法。
      Gensim加载GloVe训练的词向量
    • Doc2Vec(Gensim)
      Doc2vec是在Word2vec的基础上做出的改进,它不仅考虑了词和词之间的语义,也考虑了词序。
      Doc2Vec有两种模型,分别为:句向量的分布记忆模型(PV-DM: Distributed Memory Model of Paragraph Vectors)和句向量的分布词袋(PV-DBOW: Distributed Bag of Words version of Paragraph Vector)。
    • Fasttext
      Fasttext可以实现高效学习单词表示和句子分类;Fasttext是一个快速文本分类算法,与基于神经网络的分类算法相比有两大优点:
      • Fasttext在保持高精度的情况下加快了训练速度和测试速度
      • Fasttext不需要预训练好的词向量,Fasttext会自己训练词向量
    展开全文
  • Numpy库学习——向量表示

    万次阅读 多人点赞 2017-10-21 00:39:07
    Numpy库学习——向量表示在机器学习和深度学习的编程过程中,为了提高程序的运行速度,通常将模型表达式转换为向量表达式(向量化),即利用矩阵运算思想提高运行效率。那么,在Python中究竟如何利用Numpy库定义一个...
  • 跨语言词向量表示简史使用双语词典的跨语言词向量表示跨语言词嵌入与词对齐基于隐式/显式跨语言概念的表示结语 尽管原书讨论的是跨语言词向量的获得方法,但是在使用神经网络获得词向量的时代来临之前,学界就已经...
  • 下面将介绍一下正弦量可以用向量表示的原理,也提一下复数、极坐标等知识,做个人学习之用。 一,正弦量用向量表示的原理计算。 假设对于任意一个正弦量:Asin⁡aA\sin aAsina,我们都可以在坐标轴上将它表示出来: ...
  • 在基于文本向量表示的分类、聚类等任务中,文档向量是一个关键节点。如何将一篇文档用所带信息或概念的向量进行表示,是语义理解的基础。 以下介绍的文档向量皆为向量化表示后的文档向量,可以直接在高维向量空间...
  • TensorFlow:字词的向量表示  
  • 集合的位向量表示

    千次阅读 2016-08-07 10:51:03
    /*集合的位向量表示,1表示有,0表示无,这种表示可以很大的节省空间*/ #include #include #include #include #include #define MAX 1000000000 using namespace std; struct node { int Size; char *s; }; ...
  • 矩阵行列式的向量表示

    千次阅读 2014-11-03 22:07:10
    矩阵行列式的向量表示
  • 就像Word2vec模型一样,密切相关的单词的向量在向量空间中非常接近,Mol2vec可以学习指向化学相关子结构的相似方向的分子子结构的向量表示。通过将各个子结构的向量求和,最终可以将化合物编码为向量,例如,将其馈...
  • TF-IDF是Term Frequency-Inverse Document ...文本的向量表示 为了将机器学习算法或统计技术应用到任何形式的文本上,应当将文本转化为数字或向量形式。这种数字表示应当能够描绘出本文的显著特征。有很多技术都可...
  • 斯坦福大学在三月份开设了一门“深度学习与自然语言处理”的课程:CS224d: Deep Learning for Natural Language ...第三讲:高级的词向量表示(Advanced word vector representations: language models, softmax, si...
  • 每次遇到向量表示多元的情况脑子就宕机了,这里决定做一个简单的梳理。 一个样本 从基本的一个样本开始。某一个样本可以表示为xi\boldsymbol {x_i}xi​,它默认是竖着写的列向量,在有ppp个特征(维度)的情况下是...
  • 文本的向量表示 1.向量表示方法 One-Hot表达 TF-IDF权重策略 2.目的 非结构化数据到结构化数据的转化 3.本质 将词袋中的每个词表示为一个个向量(词袋中的所有词不能重复) 4.One-Hot表达例子 词袋:[am,college,...
  • 一、词向量表示 1. 独热表示(one-hot) 简单讲,就是使用一个二进制的向量来代表一个词,每个词对应一个位置,该位置为1,其他位置全为0的向量代表了这个词,词表的大小就是串的长度。这种方式简介且易于理解,但...
  • 数据的向量表示及降维问题 1)高维特征的降维,以提高运算速度 2)Whitening对特征预处理,以去除特征之间的相关性,这是很多算法的预处理步骤   向量的表示及基变换   两个维数相同的向量的内积被定义为: ...
  • 文章目录1 一般的英文文本预处理流程2 文本有哪些向量表示方法3 LSTM的结构 1 一般的英文文本预处理流程 1 数据收集 2 去除数据中非文本的部分 3 分词 4 词干提取(stemming)和词型还原(lemma) 5 转化为小写 6 ...
  • FastText词向量表示

    千次阅读 2018-11-07 10:23:43
    目前的词向量模型都是把每一个单词作为单独的向量,并没有考虑词语的内部结构,那么FastText相比于word2vec的创新就是考虑了词语的形态构成,也就是加上了sub-word的信息,这样的好处在于对于词汇量很...
  • 文本向量表示及TFIDF词汇权值

    千次阅读 2015-01-23 09:30:32
    文本向量表示及TFIDF词汇权值 链接为:http://blog.csdn.net/chl033/article/details/4735411 文本相似计算是进行文本聚类的基础,和传统结构化数值数据的聚类方法类似,文本聚类是通过计算文本之间"距离...
  • C++ : 直线的向量表示

    2021-02-26 10:22:19
    1、两点坐标表示方向向量 2、向量法计算点到直线的距离 上面2张图来源于 这里 3、C++ norm() 可以返回复数的平方大小 4、向量a与b叉乘,可以得到向量a与b组成的平行四边形的面积,平行四边形的面积又等于...
  • 目录将分词进行向量化的表示独热表示(one-hot representation)词空间模型(word space model)1.基于矩阵的分布表示2.基于聚类的分布方法3.基于神经网络的分布方法语言模型常用模型: 将分词进行向量化的表示 独热...
  • CS224N(三)Word Vectors 2GloVe全局统计信息+类比功能共现矩阵的表示最小方差目标函数GloVe总结词向量的评估内部评估外部评估内部评估方法...【笔记3-2】CS224N - 词向量表示 word2vec CS224n:深度学习的自然语...
  • TensorFlow教程之完整教程 2.7 字词的向量表示 知与谁同 2017-08-22 15:37:40 浏览67 评论0 函数 摘要: 本文档为TensorFlow参考文档,本转载已得到TensorFlow中文社区授权。 Vector Representations of...
  • 正弦量的向量表示

    千次阅读 2020-05-24 16:48:28
    正弦量的相量表示 实质:用复数表示正弦量 复数表示形式 设A为复数; 代数式 三角式 指数式 极坐标式 复数的模即为正弦量的幅值(或有效值) 复数的辐角即为正弦量的初相角 注意: 相量只是表示正弦量,而不...
  • from sklearn.preprocessing import MultiLabelBinarizermlb = MultiLabelBinarizer()df1 = pd.DataFrame(mlb.fit_transform(df['genres']),columns=mlb.classes_, index=df.index)df = df.join(df1)print (df)genre...
  • tf-idf权值的向量表示、余弦相似度

    千次阅读 2013-10-21 20:48:59
    PB10210016 徐波-第五次作业Chp.6 Ranking (10.15) 假定已知文档d1和d2和查询q的词项以及词频...请给出文档d1、d2以及查询q的基于tf-idf权值的向量表示,然后分别计算q和d1、d2的余弦相似度,并说明q和哪个文档更相

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,051
精华内容 8,020
关键字:

向量表示