精华内容
下载资源
问答
  • 我已将其重命名为包括“ 7”(因为Inform 6一种语言),并且已将“ 7”添加到所有语法类中。 正确的颜色: 带括号的字符串替换 嵌套评论 节标题行 通知6个夹杂物 扩展末尾的文档部分 我不会尝试为所有Inform ...
  • nlp-语言表示模型

    2020-08-13 16:07:13
    语言表示模型四种语言表示模型BOWOne-HotCountTFIDFN-gram方法共现矩阵主题模型LDALSA静态向量NNLMword2vecfasttextGlove合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入段漂亮的...

    四种语言表示模型

    语言表示模型有很多种方式,常见的语言表示方式可以粗略的分成非神经网络的方式、基于神经网路的方式。
    也可以分为一下四种方式:
    1.基于one-hot、tf-idf、textrank等的bag-of-words;
    2.主题模型:LSA(SVD)、pLSA、LDA;
    3.基于词向量的固定表征:word2vec、fastText、glove;
    4.基于词向量的动态表征:elmo、GPT、bert、XLnet、RoBERTa、T5、ERNIE-Baidu、ELECTRA;

    BOW

    Bag of Words(BOW),就是将文本/Query看作是一系列词的集合。由于词很多,所以咱们就用袋子把它们装起来,简称词袋。根据词语在文本中的统计信息创建文本表示模型,最常见的有one-hot表示、词频表示、tfidf表示。

    One-Hot

    方法步骤:根据文本库创建词典,再对单个文本中进行表示,如果词语出现在文本中则标注为1否则该位置标注为0
    在这里插入图片描述

    Count

    Count统计词频方法
    在这里插入图片描述

    texts=["John likes to watch movies. Mary likes too.","John also likes to watch football games."]
    from sklearn.feature_extraction.text import CountVectorizer
    # bow_vectorizer = CountVectorizer(max_df=0.9, min_df=1, max_features=10, stop_words='english')# bag-of-words feature matrix
    bow_vectorizer = CountVectorizer(max_features=4000)
    bow = bow_vectorizer.fit_transform(texts)
    print(bow_vectorizer.get_feature_names())
    print(bow.toarray())
    

    TFIDF

    在这里插入图片描述

    #TFIDF 文本表示形式
    from sklearn.feature_extraction.text import TfidfVectorizer
    vec = TfidfVectorizer(lowercase=False, max_features=4000)
    vec_matrix=vec.fit_transform(texts)
    print(vec.get_feature_names())
    print(vec_matrix.toarray())
    

    N-gram方法

    文档一:汤姆追杰瑞
    文档二:汤姆杰瑞
    文档三:杰瑞追汤姆 词袋:“汤姆追”,“追杰瑞”,“汤姆杰瑞”,“杰瑞追”,“追汤姆”。
    在这里插入图片描述

    共现矩阵

    主要用于发现主题,解决词向量相近关系的表示;
    将共现矩阵行(列)作为词向量
    例如:语料库如下:
    • I like deep learning.
    • I like NLP.
    • I enjoy flying. 则共现矩阵表示如下:(使用对称的窗函数(左右window length都为1) )
    在这里插入图片描述
    例如:“I like”出现在第1,2句话中,一共出现2次,所以=2。 对称的窗口指的是,“like I”也是2次。共现窗口中的两个词语不考虑前后顺序,所以矩阵是对称矩阵。
    将共现矩阵行(列)作为词向量表示后,可以知道like,enjoy都是在I附近且统计数目大约相等,他们意思相近。

    缺点:面临稀疏性问题、向量维数随着词典大小线性增长

    解决:SVD、PCA降维,但是计算量大

    主题模型

    主题模型用于从文本库中发现有代表性的主题(得到每个主题上面词的分布特性),并能够计算出每篇文章的主题分布。

    LDA

    隐狄利克雷模型(LDA)是利用文档中单词的共现关系来对单词按主题聚类,可以理解为“文档-单词”矩阵进行分解,得到“文档-主题”和“主题-单词”两个概率分布。

    输出:文档-主题概率分布矩阵和主题-词概率分布矩阵
    训练方法:利用文档中单词的贡献关系来对单词按主题聚类,也可以理解为对“文档-单词”进行矩阵分解(有点像ALS,即将NM矩阵分解维 NK 和 K*M两个矩阵,K为主题个数)
    用处:可以找到词与主题,主题与文档之间的关系

    LSA

    Latent Semantic Analysis(LSA)假设以一定的概率选择了一个主题,然后以一定的概率选择当前主题的词。
    LSI是基于奇异值分解(SVD)的方法来得到文本的主题的。 通过一次SVD,就可以得到文档和主题的相关度,词和词义的相关度以及词义和主题的相关度。
    LSA**举例**: 假设我们有下面这个有10个词三个文本的词频TF对应矩阵如下:
    在这里插入图片描述
    这里我们没有使用预处理,也没有使用TF-IDF,在实际应用中最好使用预处理后的TF-IDF值矩阵作为输入。我们假定对应的主题数为2,则通过SVD降维后得到的三矩阵为:(m:词语的个数,n文本个数,k主题个数)
    Amn=UmkEkkVkn A_{mn}=U_{mk}* E_{kk} *V_{kn}
    UijU_{ij}:第i个词和第j个主题的相关度
    EijE_{ij}:第i个主题和第j个主题的相关度
    VijV_{ij} :第i个文本和第j个主题的相关度
    在这里插入图片描述

    #  主题模型  https://blog.csdn.net/selinda001/article/details/80446766
    doc1 = "Sugar is bad to consume. My sister likes to have sugar, but not my father."
    doc2 = "My father spends a lot of time driving my sister around to dance practice."
    doc3 = "Doctors suggest that driving may cause increased stress and blood pressure."
    doc4 = "Sometimes I feel pressure to perform well at school, but my father never seems to drive my sister to do better."
    doc5 = "Health experts say that Sugar is not good for your lifestyle."
    
    # 整合文档数据
    doc_complete = [doc1, doc2, doc3, doc4, doc5]
    from nltk.stem.wordnet import WordNetLemmatizer
    import string
    
    stop = ["\n","\r","is","to","the","of","a","an","my","i","at","for","not","that","but"]
    exclude = set(string.punctuation)
    lemma = WordNetLemmatizer()
    
    def clean(doc):
        stop_free = " ".join([i for i in doc.lower().split() if i not in stop])
        punc_free = ''.join(ch for ch in stop_free if ch not in exclude)
        normalized = " ".join(lemma.lemmatize(word) for word in punc_free.split())
        return normalized
    
    doc_clean = [clean(doc).split() for doc in doc_complete]
    print(doc_clean)
    import numpy as np
    import gensim
    from gensim import corpora
    
    # 创建语料的词语词典,每个单独的词语都会被赋予一个索引
    dictionary = corpora.Dictionary(doc_clean)
    print(len(dictionary),dictionary)
    # 使用上面的词典,将转换文档列表(语料)变成 DT 矩阵
    doc_term_matrix = [dictionary.doc2bow(doc) for doc in doc_clean]
    print(doc_term_matrix)
    
    # 使用 gensim 来创建 LDA 模型对象
    Lda = gensim.models.ldamodel.LdaModel
    
    # 在 DT 矩阵上运行和训练 LDA 模型
    ldamodel = Lda(doc_term_matrix, num_topics=3, id2word = dictionary, passes=50)
    print(ldamodel)
    # 输出结果
    print(ldamodel.print_topics(num_topics=3, num_words=3))
    #文本主题表示
    for doc in ldamodel[doc_term_matrix]:
        print(doc)
    

    静态词向量

    BOW优点
    1、解决了分类器不好处理离散数据的问题
    2、 在一定程度上也起到了扩充特征的作用
    BOW缺点
    1、它是一个词袋模型,不考虑词与词之间的顺序(文本中词的顺序信息也是很重要的);
    2、它假设词与词相互独立(实际上大多数情况下,词与词是相互影响的);
    3、它得到的特征是离散稀疏的
    主题模型优点
    1、可以找到词与主题,主题与文档之间的关系
    主题模型缺点
    1、无法挖掘的词与词之间的相似度
    2、计算量比较大(奇异值分解SVD)

    为了解决词语向量的稀疏性问题,以及挖掘词语之间的语义关系,研究者提出了用** 词嵌入**的概念。
    词嵌入是一类将词向量化的模型的统称,核心思想是将每个词映射成低维空间(通常K=50~300维)上的一个稠密向量(Dense Vector)。
    神经网络将每个词映射成低维空间(通常K=50~300维)上的一个稠密向量(Dense Vector)。在这里插入图片描述

    利用向量之间的距离可以计算词语之间的语义关系
    在这里插入图片描述
    king和queen之间的关系相比与man与woman的关系大体应该相同的,那么他们通过矩阵运算,维持住这种关系
    Paris 和France之间的关系相比与Berlin与German的关系大体应该相同的,那么他们通过矩阵运算,维持住这种关系

    import gensim
    from gensim.models import word2vec
    word2vec_path = 'D:\py3.6code\data_nlp\word_vec\\200dim\word2vec.model'
    model=gensim.models.Word2Vec.load(word2vec_path)
    print(model.vector_size)#词向量维度
    sim_words = model.most_similar(positive=['女人'])
    for word,similarity in sim_words:
        print(word,similarity)                           # 输出’女人‘相近的词语和概率
    print(model['女孩'])                 
    

    NNLM

    神经网络语言模型(2003,A Neural Probabilistic Language Model)其用前n-1个词预测第n个词的概率,并用神经网络搭建模型。

    应用场景:已知前文数个词语,通过概率计算预测下一个词。

    思路:输入词语文本第i个词语的上下文词语(窗口大小k)oneHot编码,与矩阵C(vocabSizehiddenSize)相乘得到(oneHot编码与C矩阵形成只有编码为1的位置得到维度为)hiddenSize维度的向量;得到的khiddenSize维度矩阵,拼接起来得到(khiddenSize,)向量,在经过全连接层softmax得到下一个词语的概率,(共有vocabSize个概率,且概率之和=1)。

    输入:语料中词w以及它的上下文{w,Context(w)w,Context(w)};

    输出:预测语料中基于前文的前提下每个词的概p(w∣Context(w))p(w∣Context(w))(即类条件概率);

    目标:最大化似然函数。

    NNLM具有三层网络结构,分别为输入(投影)层、隐含层和输出层,如下图所示。
    在这里插入图片描述
    上述得到的C_vocabSize*hiddenSize 即可以将每个词语表示成一个稠密向量(Dense Vector)表示,我们称之为词嵌入表示方式。

    word2vec

    word2vec和神经网络语言模型不同,直接来学习这个词向量,使用的基本假设是分布式假设,如果两个词的上下文时相似的,那么他们语义也是相似的。

    Word2Vec是谷歌2013年提出的目前最常用的词嵌入模型之一,Word2Vec实际上是一种浅层的神经网络模型,它有两种网络结构,分别是CBOW(Continues Bag of Words)和Skip-gram。
    在这里插入图片描述
    CBOW的目标是根据上下文出现的词语来预测当前词的生成概率;而Skip-gram是根据当前词来预测上下文中各词的生成概率。CBOW和Skip-gram都可以表示成输入层(Input)、映射层(Projection)和输出层(Output)组成的神经网络。

    在神经网络语言模型的基础上做了一些简化: 这里没有做拼接,而是做了sum,直接去预测后面那个词。
    在这里插入图片描述
    word2vec 两点优化
    1、hierarchical-softmax哈夫曼树将平铺型softmax压缩成层级softmax【优点】
    (1)softmax计算量为VocabSize,现在变成了log2VocabSize,
    (2)使用霍夫曼树是高频的词靠近树根,这样高频词需要更少的时间会被找到,这符合我们的贪心优化思想。
    2、负采样 【优点】
    (1)negative sampling 每次让一个训练样本仅仅更新一小部分的权重参数,从而降低梯度下降过程中的计算量。
    (2)对频繁词进行二次抽样和应用负抽样不仅减少了训练过程的计算负担,而且还提高了其结果词向量的质量。

    fasttext

    fasttext的模型与CBOW类似,实际上,fasttext的确是由CBOW演变而来的。CBOW预测上下文的中间词,fasttext预测文本标签。与word2vec算法的衍生物相同,稠密词向量也是在训练神经网络的过程中得到的。
    在这里插入图片描述
    fasttext中采用层级softmax做分类,这与CBOW相同。fasttext算法中还考虑了词的顺序问题,即采用N-gram,与之前介绍离散表示时的做法相同。如:今天天气非常不错,Bi-gram的表示就是:今天、天天、天气、气非、非常、常不、不错。

    Glove

    Glove模型 Cbow/Skip-Gram 是一个local context window的方法,比如使用NS来训练,缺乏了整体的词和词的关系,负样本采用sample的方式会缺失词的关系信息。 另外,直接训练Skip-Gram类型的算法,很容易使得高曝光词汇得到过多的权重。
    Global Vector融合了矩阵分解Latent Semantic Analysis (LSA)的全局统计信息和local context window优势。融入全局的先验统计信息,可以加快模型的训练速度,又可以控制词的相对权重。
    我们可以通过word2vec或者 glove这种模型在大量的未标注的语料上学习,我们可以学习到比较好的向量表示,可以学习到词语之间的一些关系。比如男性和女性的关系距离,时态的关系,学到这种关系之后我们就可以把它作为特征用于后续的任务,从而提高模型的泛化能力。 但是同时存在一些问题比如:
    He deposited his money in this bank .
    His soldiers were arrayed along the river bank .
    【bank 一词多义问题】word embeding 有个问题就是我们的词通常有很多语义的,比如bank是银行还是河岸,具体的意思要取决与上下文,如果我们强行用一个向量来表示语义的话,只能把这两种语义都编码在这个向量里,但实际一个句子中,一个词只有一个语义,那么这种编码是有问题的。

    动态词向量

    静态词向量优点
    1、解决特征表示稀疏问题
    2、可以挖掘词语之间的语义关系
    静态词向量缺点
    1、无法解决一词多义的问题
    2、无法挖掘上下文语义信息
    Word2vec算法通过使用一组固定维度的向量来表示单词,但是往往一个词语在不同的语境中会有不同的意思。 eg:“长”这个字,在“长度”这个词中表示度量,在“长高”这个词中表示增加。那么为什么我们不通过“长”周围是“度”或者是“高”来判断它的读音或者它的语义呢?这个问题就派生出语境中的词嵌入模型。
    要解决这一问题,就引入了【contextual word embedding】。
    contextual word embedding:无监督的上下文的表示,这种无监督的学习是考虑上下文的,比如ELMo、OpenAI GPT、BERT都是上下文相关的表示方法。

    elmo

    ACL2017发表的《Semi-supervised sequence tagging with bidirectional language models》 EMLo改变Word2vec类的将单词固定为指定长度的向量处理方式,它是在为每个单词分配词向量之前先查看整个句子,然后使用bi-LSTM来训练它对应的词向量。
    在这里插入图片描述
    ELMO虽然用了双向的LSTM模型解决了单向流问题,但是仍然会由顺序依赖问题。

    RNN 序列依赖问题

    可以通过RNN/LSTM/GRU来解决上下文的语义问题,RNN与普通深度学习不同的是,RNN是一种序列的模型,会有一定的记忆单元,能够记住之前的历史信息,从而可以建模这种上下文相关的一些语义。RNN中的记忆单元可以记住当前词之前的信息。
    RNN序列可能会存在梯度消失或梯度爆炸的问题,因此提出LSTM模型。
    在这里插入图片描述

    RNN的三个问题
    1、顺序依赖,t依赖t-1时刻(串行的,很难并行的计算,持续的依赖的关系,通常很慢,无法并行)

    The animal didn’t cross the street because it was too tired.

    The animal didn’t cross the street because it was too narrow.

    2、单向信息流(如仅根据上文或下文的信息不能确定文中it的指代)

    3、需要一些比较多的监督数据,对于数据获取成本很高的任务,就比较困难,在实际情况中很难学到复杂的上下文关系

    为了解决以上问题研究者们提出了用Transformer模型代替LSTM模型。

    2017年6月google团队在《Attention is all your need》论文中提出的Transformer解码器作为语言模型。Transformer模型主要是利用自注意力(self-attention)机制的模型。https://www.cnblogs.com/robert-dlut/p/9824346.html
    这篇论文主要亮点在于
    (1)不同于以往主流机器翻译使用基于RNN的seq2seq模型框架,该论文用attention机制代替了RNN搭建了整个模型框架。
    (2)提出了多头注意力(Multi-headed attention)机制方法,在编码器和解码器中大量的使用了多头自注意力机制(Multi-headed self-attention)。
    (3)在WMT2014语料中的英德和英法任务上取得了先进结果,并且训练速度比主流模型更快。

    文本表示方法优缺点

    参考bert.docx文件,插入对比表格。

    参考文献

    [1] https://blog.csdn.net/jiaowoshouzi/article/details/89073944
    [2] https://www.cnblogs.com/gczr/p/11785930.html
    [3] https://blog.csdn.net/MarsYWK/article/details/86648812
    [4] https://zhuanlan.zhihu.com/p/48612853
    [5] https://blog.csdn.net/sparkexpert/article/details/79890972
    [6] https://www.cnblogs.com/robert-dlut/p/9824346.html
    [7] https://www.cnblogs.com/robert-dlut/p/8638283.html
    [8] https://zhuanlan.zhihu.com/p/106106079
    [9] https://www.cnblogs.com/robert-dlut/p/9824346.html
    [10] https://www.cnblogs.com/robert-dlut/p/8638283.html
    [11] https://zhuanlan.zhihu.com/p/106106079
    [12] https://zhuanlan.zhihu.com/p/106129657
    [13] https://blog.csdn.net/haidixipan/article/details/84299039
    [14] https://zhuanlan.zhihu.com/p/56382372
    [15] https://zhuanlan.zhihu.com/p/56382372
    [16] https://blog.csdn.net/data_scientist/article/details/79063138

    跳转下一篇Transformer:link.

    展开全文
  • 这里写目录标题一级目录二级...为了解决汉字歧义和非组成的问题,我们提出了多原型字符嵌入和一种有效的选方法。我们评估了CWE在词语相关度计算和类比推理方面的有效性。结果表明,CWE优于其他忽略内部字符信息的基


    论文链接:Joint Learning of Character and Word Embeddings
    来源:IJCAI-15
    代码:

    摘要

    大多数的词嵌入方法都是以词为基本单位,根据词的外部语境来学习词的嵌入,忽略了词的内部结构。然而,在一些语言中,如汉语,一个词通常是由几个汉字组成的,包含了丰富的内部信息。一个词的语义也与它的组成字的意义有关。因此,我们以中文为例,提出了一种字符增强的词嵌入模型。为了解决汉字歧义和非组成词的问题,我们提出了多原型字符嵌入和一种有效的选词方法。我们评估了CWE在词语相关度计算和类比推理方面的有效性。结果表明,CWE优于其他忽略内部字符信息的基准方法。

    引言

    作为文本表示的基础,词表示的目的是将词表示为一个向量,既可以用来计算词之间的语义关系,也可以作为词的特征提供给机器学习系统。
    许多自然语言处理任务通常采用一个one-hot向量表示,即每个词都被表示为一个词汇量向量,只有一个非零条目。由于其简单性,one-hot表示在NLP和IR中被广泛采用,作为BOW (bag-of-word)文档模型的基础[Manning等人,2008]。单一热点表征法最关键的缺陷是,它没有考虑到词语之间的任何语义关联。
    分布式词表示(Distributed word representation),也称为词嵌入(word embedding),最早是在[Rumelhart et al., 1986]提出的。词嵌入将一个词的语义编码成一个实值的低维向量。近年来,词嵌入技术取得了重大进展,被广泛应用在自然语言处理任务,
    现有的词嵌入模型训练过程计算复杂度较高,不能有效地用于大规模文本语料库。
    本文认为汉语是一种典型的语言。在此基础上,提出了一种新的字符和词嵌入的联合学习模型——字符增强词嵌入模型(CWE)。在CWE中,我们学习并保持单词和字符的嵌入在一起。CWE可以很容易地集成到词嵌入模型中,基于CBOW的CWE框架之一如图1(B)所示,将词嵌入(图中的蓝框)和字符嵌入(绿框)组合在一起得到新的嵌入(黄框)。
    在这里插入图片描述
    CWE的框架似乎是对其他词嵌入模型的简单扩展。然而,将中文字符引入到嵌入词的学习中却面临着一些困难。(1)与词语相比,汉字的歧义性要大得多。一个字符可能在不同的词语中有不同的重要性和语义。仅用一个向量表示一个字符是不够的。(2)并非所有的汉语单词都是语义构成的,如音译词。对字的考虑会影响字和字的嵌入质量。
    在本文中,我们将采取以下方法来应对这些挑战。(1)提出了多原型字符嵌入。我们获得一个字符的多个向量,对应于该字符的各种含义。我们提出了几种可能的多原型字符嵌入方法:基于位置的方法、基于聚类的方法和非参数方法。(2)预先识别非构成词并建立单词表。然后我们把这些词作为一个整体来看待,而不再考虑它们的字符。
    在实验中,我们使用词语相关度和类比推理任务来评估CWE的性能以及包括CBOW、Skip-Gram和GloVe在内的基线[Pennington等人,2014]。结果表明,通过成功地利用字符嵌入增强单词嵌入,CWE的性能明显优于所有基线。
    注意,我们的方法在以下两方面有很大的扩展性(1)如本文所示,它可以很容易地集成到各种词嵌入方法中,包括神经网络模型框架(CBOW和Skip-Gram)和矩阵分解模型框架(GloVe),并取得了较大的改进。(2)我们的方法也适用于各种语言中含有丰富的内部信息,需要处理歧义问题的语言。

    模型

    我们将以CBOW为例,演示基于CBOW的CWE框架。

    CBOW

    字符增强的词嵌入

    多原型字符嵌入

    基于位置的字符嵌入

    基于集群的字符嵌入

    根据多原型字符嵌入方法,我们也可以简单地根据字符的上下文对字符的所有共现进行聚合,并形成字符的多个原型

    基于非参数集群的字符嵌入

    上述硬聚类分配类似于k-means聚类算法,它为每个字符学习固定数量的聚类。这里我们提出了一种基于聚类的字符嵌入的非参数版本,它为每个字符学习不同数量的聚类。遵循在线非参数聚类算法的思想[Neelakantan et al., 2014],一个字符的聚类数量是未知的,并在训练过程中学习。
    为了防止非构词词的干扰,我们提出在学习非构词词的时候不考虑字符,而同时学习其他词的词和字的嵌入。我们只需手动构建一个关于音译词的单词列表,并执行中文词性标记以识别所有实体名称。单词素词几乎不影响建模,因为它们的字符通常只出现在这些词中,没有特别处理。

    2.5 初始化和优化

    我们采用与[Mikolov et ., 2013]中使用的CBOW相似的优化方案,使用随机梯度下降(SGD)对CWE模型进行优化。梯度的计算使用反向传播算法。

    单词选择

    汉语中有许多词并没有表现出由汉字构成的语义成分。包括:(1)单词素的多字符词:例如“琵琶”、“徘徊”,很难在其他词中使用(2)音译词,例如“沙发”、“巧克力”,主要表现为语音成分。(3)许多实体名称,如人员名称、位置名称和组织名称。

    3 实验和分析

    结论

    本文将内部字符信息引入到词嵌入方法中,以减轻对外部信息的过度依赖。我们提出的字符增强的词嵌入框架(CWE),它可以很容易地集成到现有的词嵌入模型包括CBOW Skip-Gram和GloVe。在词语相似度计算和类比推理的实验,我们已经表明,用人的字符嵌入可以持续和显著提高词的质量嵌入。这表明,在像汉语这样的语言中,考虑单词表示的内部信息是必要的。
    我们未来的工作方向如下:(1)提出了一种基于词与字之间语义组合的加法运算。基于矩阵或张量的语义组合模型,我们可以探索更复杂的组合模型,从字符嵌入中建立词嵌入。这将使CWE具有更强大的内部字符信息编码能力。(2) CWE可以学习为一个单词中的字符分配不同的权重。(3)本文设计了一种简单的非构成词选择策略。在未来,我们将探索关于单词的丰富信息来建立一个用于选择的词分类器。

    展开全文
  • Word2vec提供了一种单词数字表示的方法。嵌入被用作许多任务的单词特征表示,比如图像标题生成和机器翻译。文档分类任务是词嵌入实际应用中的很简单的一个应用。在文档分类中,需要通过向量技术嵌入整个文档而...

    自然语言处理自学笔记-03 使用Word2vec进行文档分类

    使用Word2vec进行文档分类

    Word2vec提供了一种单词数字表示的方法。词嵌入被用作许多任务的单词特征表示,比如图像标题生成和机器翻译。文档分类任务是词嵌入实际应用中的很简单的一个应用。在文档分类中,需要通过词向量技术嵌入整个文档而不是单词。

    用词向量进行文档分类

    在小数据集上,CBOW算法要好于skip-gram。在这里我们使用CBOW算法来进行文档分类。过程如下:

    1. 从所有文本文件中提取数据并学习词嵌入。
    2. 从已经训练过的文档中提取一组随机文档。
    3. 用文档中找到的词嵌入向量的平均值来表示文档。
    4. 使用t-SNE可视化技术可视化找到文档嵌入。
    5. 使用K-means聚类算法进行聚类分析。

    代码实现

    from __future__ import print_function
    import collections
    import math
    import numpy as np
    import os
    import random
    import tensorflow as tf
    import zipfile
    from matplotlib import pylab
    from six.moves import range
    from six.moves.urllib.request import urlretrieve
    from sklearn.manifold import TSNE
    from sklearn.cluster import KMeans
    import nltk # standard preprocessing
    import operator # sorting items in dictionary by value
    #nltk.download() #tokenizers/punkt/PY3/english.pickle
    from math import ceil
    
    filename = 'bbc-fulltext.zip'
    
    
    def read_data(filename):
        """
        Extract articles up to a given threshold in a zip file as a list of words
        and pre-processes it using the nltk python library
        """
        data = []
        files_to_read_for_topic = 250
        topics = ['business', 'entertainment', 'politics', 'sport', 'tech']
        with zipfile.ZipFile(filename) as z:
            parent_dir = z.namelist()[0]
            for t in topics:
                print('\tFinished reading data for topic: ', t)
                for fi in range(1, files_to_read_for_topic):
                    with z.open(parent_dir + t + '/' + format(fi, '03d') + '.txt') as f:
                        file_string = f.read().decode('latin-1')
                        file_string = file_string.lower()
                        file_string = nltk.word_tokenize(file_string)
                        data.extend(file_string)
    
            return data
    
    
    def read_test_data(filename):
        """
        Extract articles up to a given threshold in a zip file as a list of words
        and pre-processes it using the nltk python library
        """
        test_data = {}
        files_to_read_for_topic = 250
        topics = ['business', 'entertainment', 'politics', 'sport', 'tech']
        with zipfile.ZipFile(filename) as z:
            parent_dir = z.namelist()[0]
            for t in topics:
                print('\tFinished reading data for topic: ', t)
    
                for fi in np.random.randint(1, files_to_read_for_topic, (10)).tolist():
                    with z.open(parent_dir + t + '/' + format(fi, '03d') + '.txt') as f:
                        file_string = f.read().decode('latin-1')
                        file_string = file_string.lower()
                        file_string = nltk.word_tokenize(file_string)
                        test_data[t + '-' + str(fi)] = file_string
    
            return test_data
    
    
    print('Processing training data...')
    words = read_data(filename)
    print('\nProcessing testing data...')
    test_words = read_test_data(filename)
    
    print('Example words (start): ', words[:10])
    print('Example words (end): ', words[-10:])
    
    vocabulary_size = 25000
    
    
    def build_dataset(words):
        # Allocate a special token for rare words
        count = [['UNK', -1]]
    
        # Gets only the vocabulary_size most common words as the vocabulary
        # All the other words will be replaced with UNK token
        count.extend(collections.Counter(words).most_common(vocabulary_size - 1))
    
        # Create an ID for each word by giving the current length of the dictionary
        # And adding that item to the dictionary
        dictionary = dict()
        for word, _ in count:
            dictionary[word] = len(dictionary)
    
        data = list()
        unk_count = 0
    
        # Traverse through all the text we have and produce a list
        # where each element corresponds to the ID of the word found at that index
        for word in words:
            # If word is in the dictionary use the word ID,
            # else use the ID of the special token "UNK"
            if word in dictionary:
                index = dictionary[word]
            else:
                index = 0  # dictionary['UNK']
                unk_count = unk_count + 1
            data.append(index)
    
        # update the count variable with the number of UNK occurences
        count[0][1] = unk_count
    
        reverse_dictionary = dict(zip(dictionary.values(), dictionary.keys()))
        # Make sure the dictionary is of size of the vocabulary
        assert len(dictionary) == vocabulary_size
    
        return data, count, dictionary, reverse_dictionary
    
    
    def build_dataset_with_existing_dictionary(words, dictionary):
        '''
        Here we use this function to convert word strings to IDs
        with a given dictionary
        '''
        data = list()
        for word in words:
            if word in dictionary:
                index = dictionary[word]
            else:
                index = 0  # dictionary['UNK']
            data.append(index)
        return data
    
    
    # Processining training data
    data, count, dictionary, reverse_dictionary = build_dataset(words)
    
    # Processing test data
    test_data = {}
    for k, v in test_words.items():
        print('Building Test Dataset for ', k, ' topic')
        test_data[k] = build_dataset_with_existing_dictionary(test_words[k], dictionary)
    
    print('Most common words (+UNK)', count[:5])
    print('Sample data', data[:10])
    print('test keys: ', test_data.keys())
    del words  # Hint to reduce memory.
    del test_words
    
    data_index = 0
    
    
    def generate_batch(data, batch_size, window_size):
        # data_index is updated by 1 everytime we read a data point
        global data_index
    
        # span defines the total window size, where
        # data we consider at an instance looks as follows.
        # [ skip_window target skip_window ]
        span = 2 * window_size + 1
    
        # two numpy arras to hold target words (batch)
        # and context words (labels)
        batch = np.ndarray(shape=(batch_size, span - 1), dtype=np.int32)
        labels = np.ndarray(shape=(batch_size, 1), dtype=np.int32)
    
        # The buffer holds the data contained within the span
        buffer = collections.deque(maxlen=span)
    
        # Fill the buffer and update the data_index
        for _ in range(span):
            buffer.append(data[data_index])
            data_index = (data_index + 1) % len(data)
    
        # This is the number of context words we sample for a single target word
        num_samples = 2 * window_size
    
        # We break the batch reading into two for loops
        # The inner for loop fills in the batch and labels with
        # num_samples data points using data contained withing the span
        # The outper for loop repeat this for batch_size//num_samples times
        # to produce a full batch
        for i in range(batch_size // num_samples):
            k = 0
            # avoid the target word itself as a prediction
            # fill in batch and label numpy arrays
            for j in list(range(window_size)) + list(range(window_size + 1, 2 * window_size + 1)):
                batch[i * num_samples + k] = buffer[window_size]
                labels[i * num_samples + k, 0] = buffer[j]
                k += 1
    
                # Everytime we read num_samples data points,
            # we have created the maximum number of datapoints possible
            # withing a single span, so we need to move the span by 1
            # to create a fresh new span
            buffer.append(data[data_index])
            data_index = (data_index + 1) % len(data)
    
        assert batch.shape[0] == batch_size and batch.shape[1] == span - 1
        return batch, labels
    
    
    for window_size in [1, 2]:
        data_index = 0
        batch, labels = generate_batch(data, batch_size=8, window_size=window_size)
        print('\nwith window_size = %d:' % (window_size))
        print('    batch:', [[reverse_dictionary[bii] for bii in bi] for bi in batch])
        print('    labels:', [reverse_dictionary[li] for li in labels.reshape(8)])
    
    test_data_index = 0
    
    def generate_test_batch(data, batch_size):
        '''
        Generate a batch of data from the test data
        This is used to compute the document embedding
        by taking the average of all the words in a document
        '''
        global test_data_index
    
        batch = np.ndarray(shape=(batch_size,), dtype=np.int32)
        # Get words starting from index 0 to span
        for bi in range(batch_size):
            batch[bi] = data[test_data_index]
            test_data_index = (test_data_index + 1) % len(data)
    
        return batch
    
    test_data_index = 0
    test_batch = generate_test_batch(test_data[list(test_data.keys())[0]], batch_size=8)
    print('\nwith window_size = %d:' % (window_size))
    print('    labels:', [reverse_dictionary[li] for li in test_batch.reshape(8)])
    
    batch_size = 128 # Data points in a single batch
    embedding_size = 128 # Dimension of the embedding vector.
    window_size = 4 # How many words to consider left and right.
    
    # We pick a random validation set to sample nearest neighbors
    valid_size = 16 # Random set of words to evaluate similarity on.
    # We sample valid datapoints randomly from a large window without always being deterministic
    valid_window = 50
    
    # When selecting valid examples, we select some of the most frequent words as well as
    # some moderately rare words as well
    valid_examples = np.array(random.sample(range(valid_window), valid_size))
    valid_examples = np.append(valid_examples,random.sample(range(1000, 1000+valid_window), valid_size),axis=0)
    
    num_sampled = 32 # Number of negative examples to sample.
    
    tf.reset_default_graph()
    
    # Training input data (target word IDs).
    train_dataset = tf.placeholder(tf.int32, shape=[batch_size,2*window_size])
    
    # Training input label data (context word IDs)
    train_labels = tf.placeholder(tf.int32, shape=[batch_size, 1])
    
    # Validation input data, we don't need a placeholder
    # as we have already defined the IDs of the words selected
    # as validation data used to evaluate the word vectors
    valid_dataset = tf.constant(valid_examples, dtype=tf.int32)
    
    # Test data. This is used to compute the document embeddings by averaging
    # word embeddings of a given document
    test_labels = tf.placeholder(tf.int32, shape=[batch_size],name='test_dataset')
    
    # Variables.
    # embedding, vector for each word in the vocabulary
    embeddings = tf.Variable(tf.random_uniform([vocabulary_size, embedding_size], -1.0, 1.0,dtype=tf.float32))
    softmax_weights = tf.Variable(tf.truncated_normal([vocabulary_size, embedding_size],
                         stddev=1.0 / math.sqrt(embedding_size),dtype=tf.float32))
    softmax_biases = tf.Variable(tf.zeros([vocabulary_size],dtype=tf.float32))
    
    # Used to compute document embeddings by averaging all the word vectors of a
    # given batch of test data
    mean_batch_embedding = tf.reduce_mean(tf.nn.embedding_lookup(embeddings, test_labels), axis=0)
    
    # Model.
    # Look up embeddings for all the context words of the inputs.
    # Then compute a tensor by staking embeddings of all context words
    stacked_embedings = None
    print('Defining %d embedding lookups representing each word in the context' % (2 * window_size))
    for i in range(2 * window_size):
        embedding_i = tf.nn.embedding_lookup(embeddings, train_dataset[:, i])
        x_size, y_size = embedding_i.get_shape().as_list()
        if stacked_embedings is None:
            stacked_embedings = tf.reshape(embedding_i, [x_size, y_size, 1])
        else:
            stacked_embedings = tf.concat(axis=2, values=[stacked_embedings, tf.reshape(embedding_i, [x_size, y_size, 1])])
    
    # Make sure the staked embeddings have 2*window_size columns
    assert stacked_embedings.get_shape().as_list()[2] == 2 * window_size
    print("Stacked embedding size: %s" % stacked_embedings.get_shape().as_list())
    
    # Compute mean embeddings by taking the mean of the tensor containing the stack of embeddings
    mean_embeddings = tf.reduce_mean(stacked_embedings, 2, keepdims=False)
    print("Reduced mean embedding size: %s" % mean_embeddings.get_shape().as_list())
    
    # Compute the softmax loss, using a sample of the negative labels each time.
    # inputs are embeddings of the train words
    # with this loss we optimize weights, biases, embeddings
    
    # If you see the warning
    # WARNING:tensorflow:From c:\...\lib\site-packages\tensorflow\python\ops\nn_impl.py:1346:
    # softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and
    # will be removed in a future version.
    # You can ignore this. This caused by the internally used softmax_cross_entropy_with_logits function
    loss = tf.reduce_mean(
        tf.nn.sampled_softmax_loss(weights=softmax_weights, biases=softmax_biases, inputs=mean_embeddings,
                               labels=train_labels, num_sampled=num_sampled, num_classes=vocabulary_size))
    
    # Compute the similarity between minibatch examples and all embeddings.
    # We use the cosine distance:
    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, tf.transpose(normalized_embeddings))
    
    # Optimizer. Adagrad optimizers has learning rates assigned to individual parameters
    optimizer = tf.train.AdagradOptimizer(1.0).minimize(loss)
    
    num_steps = 100001
    cbow_loss = []
    
    config = tf.ConfigProto(allow_soft_placement=True)
    # This is an important setting and with limited GPU memory,
    # not using this option might lead to the following error.
    # InternalError (see above for traceback): Blas GEMM launch failed : ...
    config.gpu_options.allow_growth = True
    
    with tf.Session(config=config) as session:
        # Initialize the variables in the graph
        tf.global_variables_initializer().run()
        print('Initialized')
    
        average_loss = 0
    
        # Train the Word2vec model for num_step iterations
        for step in range(num_steps):
    
            # Generate a single batch of data
            batch_data, batch_labels = generate_batch(data, batch_size, window_size)
    
            # Populate the feed_dict and run the optimizer (minimize loss)
            # and compute the loss
            feed_dict = {train_dataset: batch_data, train_labels: batch_labels}
            _, l = session.run([optimizer, loss], feed_dict=feed_dict)
    
            # Update the average loss variable
            average_loss += l
    
            if (step + 1) % 2000 == 0:
                if step > 0:
                    average_loss = average_loss / 2000
                    # The average loss is an estimate of the loss over the last 2000 batches.
                print('Average loss at step %d: %f' % (step + 1, average_loss))
                cbow_loss.append(average_loss)
                average_loss = 0
    
            # Evaluating validation set word similarities
            if (step + 1) % 10000 == 0:
                sim = similarity.eval()
                # Here we compute the top_k closest words for a given validation word
                # in terms of the cosine distance
                # We do this for all the words in the validation set
                # Note: This is an expensive step
                for i in range(valid_size):
                    valid_word = reverse_dictionary[valid_examples[i]]
                    top_k = 8  # number of nearest neighbors
                    nearest = (-sim[i, :]).argsort()[1:top_k + 1]
                    log = 'Nearest to %s:' % valid_word
                    for k in range(top_k):
                        close_word = reverse_dictionary[nearest[k]]
                        log = '%s %s,' % (log, close_word)
                    print(log)
    
        # Computing test documents embeddings by averaging word embeddings
    
        # We take batch_size*num_test_steps words from each document
        # to compute document embeddings
        num_test_steps = 100
    
        # Store document embeddings
        # {document_id:embedding} format
        document_embeddings = {}
        print('Testing Phase (Compute document embeddings)')
    
        # For each test document compute document embeddings
        for k, v in test_data.items():
            print('\tCalculating mean embedding for document ', k, ' with ', num_test_steps, ' steps.')
            test_data_index = 0
            topic_mean_batch_embeddings = np.empty((num_test_steps, embedding_size), dtype=np.float32)
    
            # keep averaging mean word embeddings obtained for each step
            for test_step in range(num_test_steps):
                test_batch_labels = generate_test_batch(test_data[k], batch_size)
                batch_mean = session.run(mean_batch_embedding, feed_dict={test_labels: test_batch_labels})
                topic_mean_batch_embeddings[test_step, :] = batch_mean
            document_embeddings[k] = np.mean(topic_mean_batch_embeddings, axis=0)
    
        # Number of data points to visualize
        num_points = 1000
    
        # Create a t-SNE object
        tsne = TSNE(perplexity=30, n_components=2, init='pca', n_iter=5000)
    
        print('Fitting embeddings to T-SNE')
        # get the T-SNE manifold
        doc_ids, doc_embeddings = zip(*document_embeddings.items())
        two_d_embeddings = tsne.fit_transform(doc_embeddings)
        print('\tDone')
    
    
        def plot(embeddings, labels):
    
            n_clusters = 5  # number of clusters
    
            # automatically build a discrete set of colors, each for cluster
            label_colors = [pylab.cm.nipy_spectral(float(i) / n_clusters) for i in range(n_clusters)]
            label_markers = ['o', '^', 'd', 's', 'x']
            # make sure the number of document embeddings is same as
            # point labels provided
            assert embeddings.shape[0] >= len(labels), 'More labels than embeddings'
    
            pylab.figure(figsize=(15, 15))  # in inches
    
            def get_label_id_from_key(key):
                '''
                We assign each different category a cluster_id
                This is assigned based on what is contained in the point label
                Not the actual clustering results
                '''
                if 'business' in key:
                    return 0
                elif 'entertainment' in key:
                    return 1
                elif 'politics' in key:
                    return 2
                elif 'sport' in key:
                    return 3
                elif 'tech' in key:
                    return 4
    
            # Plot all the document embeddings and their corresponding words
            for i, label in enumerate(labels):
                x, y = embeddings[i, :]
                pylab.scatter(x, y, c=label_colors[get_label_id_from_key(label)], s=50,
                              marker=label_markers[get_label_id_from_key(label)])
    
                # Annotate each point on the scatter plot
                pylab.annotate(label, xy=(x, y), xytext=(5, 2), textcoords='offset points',
                               ha='right', va='bottom', fontsize=16)
    
            # Set plot title
            pylab.title('Document Embeddings visualized with t-SNE', fontsize=24)
    
            # Use for saving the figure if needed
            pylab.savefig('document_embeddings.png')
            pylab.show()
    
    
        # Run the plotting function
        plot(two_d_embeddings, doc_ids)
    
        # Create and fit K-means
        kmeans = KMeans(n_clusters=5, random_state=43643, max_iter=10000, n_init=100, algorithm='elkan')
        kmeans.fit(np.array(list(document_embeddings.values())))
    
        # Compute items fallen within each cluster
        document_classes = {}
        for inp, lbl in zip(list(document_embeddings.keys()), kmeans.labels_):
            if lbl not in document_classes:
                document_classes[lbl] = [inp]
            else:
                document_classes[lbl].append(inp)
        for k, v in document_classes.items():
            print('\nDocuments in Cluster ', k)
            print('\t', v)
    
    

    加粗样式
    测试数据可以直接下载。

    展开全文
  • 还有一种建站方法建立技术型的网站。例如搜索引擎自己没什么内容,但是它通过搜索技术获得了巨大的内容。现在“美加新闻聚合系统”,站长已经可以免费获得并使用。利用这种软件建立技术型网站就非常容易了。就像...
  • 还有一种建站方法建立技术型的网站。例如搜索引擎自己没什么内容,但是它通过搜索技术获得了巨大的内容。现在“美加新闻聚合系统”,站长已经可以免费获得并使用。利用这种软件建立技术型网站就非常容易了。就像...
  • XML的第一个词是\"扩展性\",这正是XML强大的功能和弹性的原因。...这表明了作为一种语言XML必须遵循一定的规则。虽然XML的扩展性允许你创建新标识,但它仍然必须遵循特定的结构,语法和明确的定义。
  • GitHub搜索API 个简单的Python脚本可获取GitHub上任何搜索查询的前1000个最佳匹配结果的详细信息 ...存储库中使用的语言词典以及每种语言的%份额 去做: 在终端中添加进度条添加对其他搜索参数的支持
  • 谁发明了“芸花现”?

    千次阅读 2006-12-10 16:01:00
    看到csdn首页上的这个标题,感觉很不舒服:Ruby语言只是芸花现我不知道“芸花现”这个词是谁发明的。没有《新华词典》的可以查查金山词霸:“昙花一现tánhuā-yīxiàn[flower briefly as the broad-leaved ...

    看到csdn首页上的这个标题,感觉很不舒服:

    Ruby语言只是花一现

    我不知道“芸花一现”这个词是谁发明的。

    没有《新华词典》的可以查查金山词霸:
    花一现
    tánhuā-yīxiàn
    [flower briefly as the broad-leaved epiphyllum;last briefly;be a flash in the pan] 印度的一种优昙钵花开放之后很快就谢萎。比喻世事没有生命力或人物经不起历史考验,偶现即逝”。

    UPDATE(2006-12-11):

    microrain的blog 已经改正了,但是 CSDN blog 首页 上仍然是“芸花”……

    展开全文
  • 主题词是用来描述文献资料主题和给出检索文献资料的一种新型的情报检索语言词汇,正是由于它的出现和发展,才使得情报检索计算机化(计算机检索)成为可能。 主题词是指以概念的特性关系来区分事物,用自然语言来...
  • 主题抽取的核心——主题词表

    千次阅读 2019-11-26 16:53:46
    主题词表又称叙词表,将文献标引人员或用户的自然语言转换成规范化语言一种术语控制工具;它概括各门或某一门专业学科领域并由语义相关,族性相关的术语组成的可不断扩充的规范化词表。主题表通常包括标题表...
  • html基础知识点合集

    千次阅读 2020-03-13 10:15:56
    是用来描述网页的一种语言。 所谓超文本,因为它可以加入图片、声音、动画、多媒体等内容,不仅如此,它还可以从一个文件跳转到另一个文件,与世界各地主机的文件连接。 <h1> 我是一个大标题 </h1> ...
  • HTML不是一种编程语言,而是一种标记语言,有着一套标记标签。HTML使用标记标签来描述网页。 标签的用途 我们学习网页制作时,常常会听到一个,语义化。那么什么叫做语义化呢,说的通俗点就是:明白每个标签的用途...
  • DTD是一种保证XML文档格式正确的有效方法,可以比较XML文档和DTD文件来看文档是否符合规范,元素和标签使用是否正确。一个DTD文档包含:元素的定义规则,元素间关系的定义规则,元素可使用的属性,可使用的实体或...
  • 这里写自定义目录标题YAMLYAML-CPP安装部署JSONJSONCPP安装部署代码头文件YamlToJsonJsonToYaml测试代码test.yaml文件测试代码输出结果总结其他 ...它是一种直观的能够被电脑识别的数据序列化格式...
  • Markdown 常用语法笔记

    2020-04-01 18:11:52
    Markdown 是一种轻量级标记语言,能将文本换成有效的XHTML(或者HTML)文档,它的目标是实现易读易写,成为一种适用于网络的书写语言标题 # H1 ## H2 ### H3 #### H4 ##### H5 ###### H6 注意 # 后面的空格 ...
  • 主要内容有C#开发环境的使用、C#语言基础应用、字符串处理技术、数组和集合的使用、面向对象编程技术、数据结构与算法、Windows窗体基础、特色窗体界面、窗体控制技术、MDI窗体和继承窗体、Windows常用控件的使用、...
  • 第10—13章介绍了有关安全的几个内容(权限、角色、概要文件、用户的管理),第14—17章介绍了几方案对象(表、索引、视图、同义和序列)的管理,第18~19章分别介绍了SOLDeveloper的使用、数据库的备份与恢复...
  • 免责声明:不要被标题吓到,我只希望正在编写智能合约的人员能够确保他们了解令牌智能合约的这一非常重要的部分。 欢迎来到我的Cadence博客!...这里的“令牌”一可以指这两种智能合约中的任何一种:
  • 在做部门工作汇报时,同事做的数据分析报告总能得到老板的赏识,再看看自己做得报告总...其实,标题是一种语言艺术,好的标题不仅可以很好的展现数据分析报告的主题,还能激发读者的阅读兴趣。 比较常规的报告标题
  • 作者认为Tri-Grams’n’Tages(TnT)可以作为一种有效的词性标记统计方法,并且作者认为基于马尔科夫(Markov model)的标记器理论上性能和其他模型相当的,此外使用平滑的方法(Smoothing)处理了未出现的概率...
  • ”, ——黄志洪 ITPUB和炼数成金创始人, “极客不是一种身份,而是一种态度。在我眼里,这个词是中性的,极客不代表一个人有多牛,而是他的钻研态度、好奇心以及对新技术的识别和接受能力。张丹这本书给大家提供了一...
  • Shur9000-crx插件

    2021-03-19 03:30:56
    - 突出显示由另一种颜色的线程所写的消息的可能性 - 直接从论坛中添加图片上传到imgur的功能(拖放) - 隐藏标题包含“Podemos”,“fútbol”,“plataforma”等任何其他字的线程的可能性。 - 过滤由一个或多...
  • Google Refine(后来的OpenRefine)开发的一种算法。 对原始算法的(可选)改进以粗体显示。 删除前导和尾随空格 将所有字符更改为小写形式 删除所有标点和控制字符 将扩展的西方字符归一化为其ASCII表示形式...
  • 这些规则以一种易于格式语言(称为,这应该使它们具有很高的可读性和易于编辑的功能,所以请随时这样做! 那太复杂了! 我们确实意识到它可能看起来像那样。 如果您不满意使用上述过程来建议更改,请随时上创建新...
  • UNA,源自拉丁形容“together”,是一种协作式的实时源代码开发环境,允许两个或更多的开发者同时编辑相同的代码。支持大部分流行的程序语言,如Ada、C、Cobol、C++、C#、CSS、Erlang、Haskell、JavaScript, Lisp...
  • php高级开发教程说明

    2008-11-27 11:39:22
    尽管它被称之为一种语言,但P H P并不是一种真正独立 的语言,而是许多语言的混和体。它主要用C的句法,但与C有很大不同。它是被解释的, P H P 能识别不同的变量类型,但没有严格的类型检查, P H P识别类,但没有...
  • pretrain Chinese Model 、albert-chinese-ner - 用预训练语言模型ALBERT做中文NER 、基于GPT2的特定主题文本生成/文本增广、开源预训练语言模型合集、多语言句向量包、编码、标记和实现:一种可控高效的文本生成...
  • 在Junglee.com上搜索和发现你最喜欢的产品,这是一种快速而简单的搜索方法。 Junglee.com是亚马逊提供的在线产品比较和广告网站,使客户能够从印度的在线和线下零售商以及Amazon.com查找和发现产品。 “在Junglee上...

空空如也

空空如也

1 2 3 4 5
收藏数 98
精华内容 39
关键字:

标题词语言是一种