天道酬勤,学无止境

每n个词分割一个词向量(向量在列表中)(split vectors of words by every n words (vectors are in a list))

问题

如何最好地分割列表中单词的向量? 这是我当前正在做的事情(这是由于geektrader的回答),但是它使RStudio颤抖并冻结了很多。 这个问题与我先前的问题紧密相关。 这里的新功能是列表结构,它更接近我的实际用例。

# reproducible data
examp1 <- "When discussing performance with colleagues, teaching, sending a bug report or searching for guidance on mailing lists and here on SO, a reproducible example is often asked and always helpful. What are your tips for creating an excellent example? How do you paste data structures from r in a text format? What other information should you include? Are there other tricks in addition to using dput(), dump() or structure()? When should you include library() or require() statements? Which reserved words should one avoid, in addition to c, df, data, etc? How does one make a great r reproducible example?"
examp2 <- "Sometimes the problem really isn't reproducible with a smaller piece of data, no matter how hard you try, and doesn't happen with synthetic data (although it's useful to show how you produced synthetic data sets that did not reproduce the problem, because it rules out some hypotheses). Posting the data to the web somewhere and providing a URL may be necessary. If the data can't be released to the public at large but could be shared at all, then you may be able to offer to e-mail it to interested parties (although this will cut down the number of people who will bother to work on it). I haven't actually seen this done, because people who can't release their data are sensitive about releasing it any form, but it would seem plausible that in some cases one could still post data if it were sufficiently anonymized/scrambled/corrupted slightly in some way. If you can't do either of these then you probably need to hire a consultant to solve your problem" 
examp3 <- "You are most likely to get good help with your R problem if you provide a reproducible example. A reproducible example allows someone else to recreate your problem by just copying and pasting R code. There are four things you need to include to make your example reproducible: required packages, data, code, and a description of your R environment. Packages should be loaded at the top of the script, so it's easy to see which ones the example needs. The easiest way to include data in an email is to use dput() to generate the R code to recreate it. For example, to recreate the mtcars dataset in R, I'd perform the following steps: Run dput(mtcars) in R Copy the output In my reproducible script, type mtcars <- then paste. Spend a little bit of time ensuring that your code is easy for others to read: make sure you've used spaces and your variable names are concise, but informative, use comments to indicate where your problem lies, do your best to remove everything that is not related to the problem. The shorter your code is, the easier it is to understand. Include the output of sessionInfo() as a comment. This summarises your R environment and makes it easy to check if you're using an out-of-date package. You can check you have actually made a reproducible example by starting up a fresh R session and pasting your script in. Before putting all of your code in an email, consider putting it on http://gist.github.com/. It will give your code nice syntax highlighting, and you don't have to worry about anything getting mangled by the email system."
examp4 <- "Do your homework before posting: If it is clear that you have done basic background research, you are far more likely to get an informative response. See also Further Resources further down this page. Do help.search(keyword) and apropos(keyword) with different keywords (type this at the R prompt). Do RSiteSearch(keyword) with different keywords (at the R prompt) to search R functions, contributed packages and R-Help postings. See ?RSiteSearch for further options and to restrict searches. Read the online help for relevant functions (type ?functionname, e.g., ?prod, at the R prompt) If something seems to have changed in R, look in the latest NEWS file on CRAN for information about it. Search the R-faq and the R-windows-faq if it might be relevant (http://cran.r-project.org/faqs.html) Read at least the relevant section in An Introduction to R If the function is from a package accompanying a book, e.g., the MASS package, consult the book before posting. The R Wiki has a section on finding functions and documentation"
examp5 <- "Before asking a technical question by e-mail, or in a newsgroup, or on a website chat board, do the following:  Try to find an answer by searching the archives of the forum you plan to post to. Try to find an answer by searching the Web. Try to find an answer by reading the manual. Try to find an answer by reading a FAQ. Try to find an answer by inspection or experimentation. Try to find an answer by asking a skilled friend. If you're a programmer, try to find an answer by reading the source code. When you ask your question, display the fact that you have done these things first; this will help establish that you're not being a lazy sponge and wasting people's time. Better yet, display what you have learned from doing these things. We like answering questions for people who have demonstrated they can learn from the answers. Use tactics like doing a Google search on the text of whatever error message you get (searching Google groups as well as Web pages). This might well take you straight to fix documentation or a mailing list thread answering your question. Even if it doesn't, saying “I googled on the following phrase but didn't get anything that looked promising” is a good thing to do in e-mail or news postings requesting help, if only because it records what searches won't help. It will also help to direct other people with similar problems to your thread by linking the search terms to what will hopefully be your problem and resolution thread. Take your time. Do not expect to be able to solve a complicated problem with a few seconds of Googling. Read and understand the FAQs, sit back, relax and give the problem some thought before approaching experts. Trust us, they will be able to tell from your questions how much reading and thinking you did, and will be more willing to help if you come prepared. Don't instantly fire your whole arsenal of questions just because your first search turned up no answers (or too many). Prepare your question. Think it through. Hasty-sounding questions get hasty answers, or none at all. The more you do to demonstrate that having put thought and effort into solving your problem before seeking help, the more likely you are to actually get help. Beware of asking the wrong question. If you ask one that is based on faulty assumptions, J. Random Hacker is quite likely to reply with a uselessly literal answer while thinking Stupid question..., and hoping the experience of getting what you asked for rather than what you needed will teach you a lesson."

# make a big list of character vectors containing words
list_examps <- lapply(1:5, function(i) eval(parse(text=paste0("examp",i))))
list_examps <- rep(list_examps, 2000)

# my current method
n <- 30 # number of words in each chunk
temp1 <- vector("list", length(list_examps))
temp2 <- vector("list", length(list_examps))
for(i in 1:length(list_examps))
{
  temp1[[i]] <- unlist(strsplit(list_examps[[i]], " "))
  temp2[[i]] <- split(unlist(strsplit(temp1[[i]] , " ")),
                      seq_along(unlist(strsplit(temp1[[i]], " ")))%/%n)
}
listofnwords <- unlist(temp2, recursive = FALSE) # desired output

有没有更有效的方法可以做到这一点?

UPDATE 1添加了(相当适中)机器规格

 > sessionInfo()
    R version 3.0.0 (2013-04-03)
    Platform: x86_64-w64-mingw32/x64 (64-bit)

    locale:
    [1] LC_COLLATE=English_United States.1252  LC_CTYPE=English_United States.1252   
    [3] LC_MONETARY=English_United States.1252 LC_NUMERIC=C                          
    [5] LC_TIME=English_United States.1252    

    attached base packages:
    [1] stats     graphics  grDevices utils     datasets  methods   base     

    loaded via a namespace (and not attached):
    [1] tools_3.0.0

    > gc()
              used (Mb) gc trigger (Mb) max used (Mb)
    Ncells  434928 23.3     818163 43.7   667722 35.7
    Vcells 7086406 54.1   12291671 93.8 12291671 93.8

> Sys.getenv()  # relevant exerpts, far off to the right for some reason...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           NUMBER_OF_PROCESSORS 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "4" 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             OS 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   "Windows_NT" 

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         PROCESSOR_ARCHITECTURE 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "AMD64" 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           PROCESSOR_IDENTIFIER 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           "Intel64 Family 6 Model 42 Stepping 7, GenuineIntel" 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                PROCESSOR_LEVEL 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "6" 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             PROCESSOR_REVISION 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         "2a07" 

更新2使用上述EC2实例(免费套餐)上的数据,加快答案的测试速度。 赢家是... SimonO101! 感谢大家的帮助。

# make a big list of character vectors containing words
list_examps <- lapply(1:5, function(i) eval(parse(text=paste0("examp",i))))
list_examps <- rep(list_examps, 200)

# my current method
n <- 30 # number of words in each chunk
temp1 <- vector("list", length(list_examps))
temp2 <- vector("list", length(list_examps))

me <- function(list_examps){
  for(i in 1:length(list_examps))
  {
    temp1[[i]] <- unlist(strsplit(list_examps[[i]], " "))
    temp2[[i]] <- split(unlist(strsplit(temp1[[i]] , " ")),
                        seq_along(unlist(strsplit(temp1[[i]], " ")))%/%n)
  }
  listofnwords <- unlist(temp2, recursive = FALSE) # desired output
}

dr <- function(list_examps){
  f <- function(list_examps) {
    y <- unlist(strsplit(list_examps, " "))
    ly <- length(y)
    split(y, gl(ly%/%n+1, n, ly))
  }

  listofnwords <- sapply(list_examps, f)
  listofnwords <- unlist(listofnwords, recursive=F)
}

si <- function( list_examps ){

  words <- unlist( ( sapply( list_examps , strsplit , " " ) ) )
  results <- lapply( seq( 0, length(words) , by = n ) , function(x) c( words[(x+1):(x+n)] ) )

}

er <- function( x ){
  x <- do.call(paste, x)
  x <- strsplit(x, ' ')[[1]]
  result <- split(x, cut(seq_along(x), breaks = seq(0, by = n, length(x)) , include.lowest = TRUE ) )
}


library(rbenchmark)

benchmark(
  me(list_examps),
  dr(list_examps),
  si(list_examps),
  er(list_examps),
  replications = 10)

结果如下:

             test replications elapsed relative user.self sys.self user.child sys.child
2 dr(list_examps)           10  48.104    1.119    47.907    0.000          0         0
4 er(list_examps)           10  71.316    1.660    70.645    0.568          0         0
1 me(list_examps)           10  48.156    1.121    48.543    0.000          0         0
3 si(list_examps)           10  42.971    1.000    42.875    0.000          0         0
回答1

可能的解决方案:

f <- function(x) {
  y <- unlist(strsplit(x, " "))
  ly <- length(y)
  split(y, gl(ly%/%n+1, n, ly))
  }

listofnwords <- sapply(list_examps, f)
listofnwords <- unlist(listofnwords, recursive=F)
回答2

这个怎么样?

x <- do.call(paste, list_examps)
x <- strsplit(x, ' ')[[1]]
result <- split(x, cut(seq_along(x), breaks = seq(0, by = 30, length(x) ) ) )
result[[1]]
回答3

我将使用sapplyunlist来获取单词,然后使用lapply将它们连接起来以列出每个包含30个单词的项目(在您的示例中,这需要1.6秒):

f1 <- function( x ){

  words <- unlist( ( sapply( list_examps , strsplit , " " ) ) )
  results <- lapply( seq( 0, length(words) , by = 30 ) , function(x) c( words[(x+1):(x+30)] ) )

}

与其他定义为以下解决方案的比较:

f2 <- function( x ){
  x <- do.call(paste, x)
  x <- strsplit(x, ' ')[[1]]
  result <- split(x, cut(seq_along(x), breaks = seq(1, by = 30, length(x)) , include.lowest = TRUE ) )
}

我们看到在此示例中,对lapply和sapply的使用将以大约两倍的速度运行(但是根据您的使用情况,它可能会发生变化):

microbenchmark( f1( list_examps) , f2( list_examps ) , times = 10L )
#Unit: seconds
#           expr      min       lq   median       uq      max neval
# f1(list_examps) 1.463855 1.531033 1.596762 1.667241 1.815084    10
# f2(list_examps) 2.787036 2.884537 2.945287 3.019572 3.357706    10
标签

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • 使用Pytorch简单实现NNLM(Nerual Network Language Model)
    前言 NNLM在NLP中有着举足轻重的地位,该模型将深度学习运用到了NLP中,其副产物词向量更是开创了NLP中预训练模型的先河,此文章使用Pytorch实现了NNLM的模型结构,并用简单的数据进行了模型的训练和测试。 示例代码来自于:https://wmathor.com/index.php/archives/1442/ 本文在原博客的基础上进行了一些补充,使其更加通俗易懂。 模型结构分析 NNLM的模型是一个三层的神经网络,如图所示: NNLM模型的任务是通过句子中的前n-1个词,来预测下一个词(第n个词)是什么,因此模型的输入是前n-1个词的向量化表示,在图中即是最下方的.......。在NNLM中,这种向量化表示就是one-hot编码的形式。文中有一个极其重要的矩阵Matrix C,它存储了输入中每个词的词向量表示,输入的每个词都能在矩阵中找到对应的词向量映射,如下所示: 值得注意的是,其实矩阵C就是两个神经网络层之间的权重W,从到就是矩阵的一个乘法运算,其它每个词的表示也是同样的道理。 我们得到了每个词的词向量表示后,将其拼接在一起,即进行concat操作,形成了一个(n-1)*w的向量,我们用X来表示。然后将X送入隐藏层进行计算,即图中中间的一层神经元,使用tanh作为激活函数: 用公式表达则是:,H和d分别是权重和偏置。 然后到了最后一层输出层,最后一层用于最终的分类
  • 一文总结词向量的计算、评估与优化
    为了处理语言,需要将文本信息用向量的形式表达。词向量(Word Vector)或称为词嵌入(Word Embedding)就是将词语向量化。常见的生成词向量的神经网络模型有NNLM模型,C&W模型,CBOW模型和Skip-gram模型。本文目录: 1. 词向量计算方法1.1 Word2Vec的计算1.2 Word2Vec中计算方法详解1.3 高频词(the)引起的问题 2. 优化基础2.1 梯度下降2.2 随机梯度下降 3. Word Vector优化过程3.1 SGD引起的稀疏数据3.2 两种词向量建模方案3.3 训练效率提升方案 4. 基于统计的单词向量表示4.1 共现矩阵4.2 改进思路 5. GloVe模型5.1 原理5.2 与Skip-Gram、CBOW模型比较5.3 步骤5.4 如何评估词向量的质量一、词向量计算方法1.1 word2vec的计算对一个中心词,与窗口内的context词出现的概率:通过极大似然方法最大化整个文本出现的概率:损失函数:1.2 word2vec中计算方法详解假设vocabulary包含m个词,每个词向量长度为n, 对于每一个词,作为中心词(center)和非中心词(outside)时分别使用v和u两个向量表示。在计算完成后将两个向量平均作为最终词向量表示。对每一个词作为中心词时,计算概率分布。这里假定第4个词作为中心词时,有其中
  • 一文总结词向量的计算、评估与优化
    为了处理语言,需要将文本信息用向量的形式表达。词向量(Word Vector)或称为词嵌入(Word Embedding)就是将词语向量化。常见的生成词向量的神经网络模型有NNLM模型,C&W模型,CBOW模型和Skip-gram模型。本文目录: 1. 词向量计算方法1.1 Word2Vec的计算1.2 Word2Vec中计算方法详解1.3 高频词(the)引起的问题 2. 优化基础2.1 梯度下降2.2 随机梯度下降 3. Word Vector优化过程3.1 SGD引起的稀疏数据3.2 两种词向量建模方案3.3 训练效率提升方案 4. 基于统计的单词向量表示4.1 共现矩阵4.2 改进思路 5. GloVe模型5.1 原理5.2 与Skip-Gram、CBOW模型比较5.3 步骤5.4 如何评估词向量的质量一、词向量计算方法1.1 word2vec的计算对一个中心词,与窗口内的context词出现的概率:通过极大似然方法最大化整个文本出现的概率:损失函数:1.2 word2vec中计算方法详解假设vocabulary包含m个词,每个词向量长度为n, 对于每一个词,作为中心词(center)和非中心词(outside)时分别使用v和u两个向量表示。在计算完成后将两个向量平均作为最终词向量表示。对每一个词作为中心词时,计算概率分布。这里假定第4个词作为中心词时,有其中
  • 关于词嵌入(Word Embedding)的一些总结
    看了课程半天没搞懂词嵌入是啥,梳理一下相关知识。参考: https://www.jianshu.com/p/2fbd0dde8804https://blog.csdn.net/m0_37565948/article/details/84989565https://www.cnblogs.com/wkang/p/9611257.html 词嵌入 一、关于文本与向量二、One-hot编码三、信息检索(IR)技术·Bag of wordsTF-IDF ·Bi-gram 和N-Gram 四、分布式表示(Distributed representation)1、基于矩阵的分布表示共现矩阵SVD(奇异值分解) 2、基于聚类的分布表示(没有了解)3、基于神经网络的分布表示 五、词嵌入与Word2Vec关于Word2Vec1、Skip-gram算法2、连续词袋算法(CBOW) 一、关于文本与向量 文本是一种非结构化的数据信息,是不可以直接被计算的。 文本表示的作用就是将这些非结构化的信息转化为结构化的信息,这样就可以针对文本信息做计算,来完成我们日常所能见到的文本分类,情感判断等任务。 文本表示的方法有很多种,但主要有3 类方式: 二、One-hot编码 但是在实际情况中,文本中很可能出现成千上万个不同的词,这时候向量就会非常长。其中99%以上都是 0。 one-hot 的缺点如下:
  • [NLP --- 16] Transformer的位置编码及其改进
    一. 位置编码 1. 引入 文本序列是一种时序型数据,单词之间地顺序关系往往会影响整个句子的含义。RNN网络在做文本生成时,顺序考虑每个时间步的文本信息,文本的输出会根据单词的输入顺序改变而改变,换句话说RNN模型考虑到了单词的顺序关系,因此不需要考虑单词的位置编码信息。卷积神经网络对局部词序敏感,可较好地建模N-Gram信息,这部分信息对于文本分类任务已经能取得较好地效果。但Transformer模型在处理句子时,将所有单词并行处理,由于每个单词都能考虑到整个句子所有单词的信息,因此若不考虑单词的位置编码,打乱单词顺序时,整个句子的输出应该是一样的,即Transformer模型是一种对单词位置不敏感的模型。 位置编码的方式主要有两种,一种是定义nn.Embedding子层,让整个网络学习到序列的位置编码信息,另一种是对每一个位置的单词,通过固定的函数得到单词的位置编码信息。 2. 位置编码初始模型 尽管卷积神经网络可利用序列地局部顺序信息,但没法获得相隔较远的两个单词之间的信息。论文[2]最初提出Position Embedding,编码层考虑将Word_Embedding 和 Position_Embedding 相加。这一点与Bert中的实现类似,Word_Embedding 和 Position Embedding 都需要通过训练学习得到,实现伪代码如下 def _
  • 第十课.简单文本分类
    目录 文本处理基本处理方式正则表达式去除停用词 文本表示单词表示词袋模型 实验:基于朴素贝叶斯的垃圾邮件过滤 文本处理 通常来说,在使用一个算法进行文本分类之前,需要做一些文本获取、文本处理和特征提取的工作。其中,文本获取的方式有第三方提供的语料库、通过爬虫技术获取等;文本处理主要是分词、去停用词、标准化等,特征提取则是将文本表示成特征向量的形式 基本处理方式 字符串的连接 >>> s1 = 'abc' >>> s2 = 'def' # 通过加号连接字符串 >>> s1 + s2 'abcdef' >>> s1 = 'abc' >>> s2 = 'def' # 通过jion()方法连接字符串 >>> ''.join([s1,s2]) 'abcdef' >>> s1 = 'abc' >>> s2 = 'def' # 设置连接字符为 - >>> '-'.join([s1,s2]) 'abc-def' 字符串的翻转 >>> s = 'abcdef' # 字符串翻转 >>> s[::-1] 'fedcba' 字符串的大小写转换 >>> s = 'abcdef' # 转换为大写字母 >>> s.upper() 'ABCDEF' >>> s = 'abcDEF' # 转换为小写字母 >>> s.lower() 'abcdef' 字符串的替换与删除 >>> notice =
  • CS224n 2019 Winter 笔记(一):Word Embedding:Word2vec and Glove
    CS224n笔记:Word2Vec:CBOW and Skip-Gram 摘要一、语言模型(Language Model)(一)一元模型(Unary Language Model)(二)二元模型(Bigram Model) 二、如何表示“word”——词向量(Word Vector)三、Word2Vec模型(一)Word2vec的作用(二)Continuous Bag of Words Model (CBOW)1、CBOW模型思想 (三)Skip-Gram Model四、负采样(Negative Sampling)(一)什么是负采样(二)为什么要负采样?或者说,负采样的作用是什么?五、Glove(Global Vectors for Word Representation)六、提问Reference 摘要 笔记只记个人学习重点和难点,不追求全面,只做读书过程中的疑惑解释,既做个人心得记录,也供读者参考 如有错误,烦请留言指点,谢过! 如有错误,烦请留言指点,谢过! 如有错误,烦请留言指点,谢过! 本次课Manning教授重点介绍CBOW模型和Glove模型,并为CBOW模型的目标函数做随机梯度下降推导。笔记主要记录CBOW和Skip-Gram两种模型主要流程及有关细节,顺带提一下Glove(推荐一篇博文以助理解)。 一、语言模型(Language Model)
  • 图解Transformer(完整版)!
    结构总览前言本文翻译自http://jalammar.github.io/illustrated-transformer,是笔者看过的把 Transformer 讲解得最好的文章。这篇文章从输入开始,一步一步演示了数据在 Transformer 中的流动过程。由于看过一些中文翻译的文章,感觉不够好,所以我自己翻译了一个版本,在一些难以直译的地方,我加入了一些原文没有的文字说明,来更好地解释概念。另外,我添加了一些简单的代码,实现了一个基本的 Self Attention 以及 multi-head attention 的矩阵运算。Transformer 依赖于 Self Attention 的知识。Attention 是一种在深度学习中广泛使用的方法,Attention的思想提升了机器翻译的效果。如果你还没学习 Attention,请查看这篇 Attention 的精彩讲解:https://zhuanlan.zhihu.com/p/265182368。2017 年,Google 提出了 Transformer 模型,用 Self Attention 的结构,取代了以往 NLP 任务中的 RNN 网络结构,在 WMT 2014 Englishto-German 和 WMT 2014 English-to-French两个机器翻译任务上都取得了当时 SOTA 的效果
  • Datawhale组队学习之NLP组第三天 N-gram
    Datawhale组队学习之NLP组第三天 N-gram word2vec 和 glove的区别:N-gram思想:FastText 模型:参考资料: 本篇博客主要介绍三个部分, 1、word2vec 和 glove的区别 2、介绍 n-gram 思想 3、介绍 FastText 模型 word2vec 和 glove的区别: 两者最直观的区别在于,word2vec是“predictive”的模型,而GloVe是“count-based”的模型。 不采用 negative sampling 的word2vec 速度非常快,但是准确率仅有57.4%。 但是这样的word2vec只告诉模型什么是有关的,却不告诉它什么是无关的,模型很难对无关的词进行惩罚从而提高自己的准确率。 在python的gensim这个包里,gensim.models.word2vec.Word2Vec默认是不开启negative sampling的,需要开启的话请设置negative参数。 当使用了negative sampling之后,为了将准确率提高到68.3%,word2vec就需要花较长的时间了(8h38m) 相比于word2vec,因为golve更容易并行化,所以速度更快,达到67.1%的准确率,只需要花4h12m。 由于GloVe算法本身使用了全局信息,自然内存费的也就多一些,相比之下
  • [Embeding-2]文本表示学习-词嵌入入门理解
    转载自Scofield Phil: http://www.scofield7419.xyz/2017/09/25/文本表示学习-词嵌入入门理解/ 之前一段时间,在结合深度学习做NLP的时候一直有思考一些问题,其中有一个问题算是最核心一个:究竟深度网络是怎么做到让各种NLP任务解决地如何完美呢?到底我的数据在NN中发什么了什么呢? 并且,不少的terms like: 词向量、word embedding、分布式表示、word2vec、glove等等,这一锅粥的名词术语分别代表什么,他们具体的关系是什么,他们是否处于平级关系?出于对知识结构追求完整梳理的强迫症的老毛病,于是不停地查资料、思考、keep revolving……然后就感觉有一点小进展了。想到,不如将个人对其的理解,无论对错,先拿出来跟peer分享下,或许能交换出更有意义的东西呢?整篇文章的构架是按照属于概念在逻辑上的先后大小顺序,一层一层一级一级地往下剖析、比较、说明。另外说明下,here整篇文字内容相对是比较入门,甚至有的点可能描述的不太客观正确,限于当前的认知水平……还请您海涵,希望您在评论中指正! 1. DeepNLP的核心关键:语言表示(Representation) 最近有一个新名词:Deep Learning + NLP = DeepNLP。当常规的Machine Learning升级发展到了一定的阶段后
  • NNLM(Nerual Network Language Model)论文笔记
    NNLM(Nerual Network Language Model)是2003年Bengio等人在文章A neural probabilistic language model提出的语言模型 基本思想 假定词表中的每一个word都对应着一个连续的特征向量假定一个连续平滑的概率模型,输入一段词向量的序列,可以输出这段序列的联合概率 P ^ ( w 1 , w 2 , . . . , w T ) = ∏ i = 1 T P ^ ( w t ∣ w 1 , w 2 , . . . , w t − 1 ) \hat{P}(w_1,w_2,...,w_T) = \prod_{i=1}^T\hat{P}(w_t|w_1,w_2,...,w_{t-1}) P^(w1​,w2​,...,wT​)=i=1∏T​P^(wt​∣w1​,w2​,...,wt−1​) P ^ ( w 1 , w 2 , . . . , w t − 1 ) ≈ P ^ ( w t ∣ w t − 1 , w t , . . . , w t − n + 1 ) \hat{P}(w_1,w_2,...,w_{t-1}) \approx \hat{P}(w_t|w_{t-1},w_t,...,w_{t-n+1}) P^(w1​,w2​,...,wt−1​)≈P^(wt​∣wt−1​,wt​,...,wt−n+1​) w t
  • 【学习笔记】零基础入门NLP - 新闻文本分类实战
    赛题理解   首先要理解赛题的背景及描述——赛题以新闻数据为赛题数据,数据集报名后可见并可下载。赛题数据为新闻文本,并按照字符级别进行匿名处理。整合划分出14个候选分类类别:财经、彩票、房产、股票、家居、教育、科技、社会、时尚、时政、体育、星座、游戏、娱乐的文本数据。通过描述,我们可以知道这道题是要通过给定的一段文本来判断是属于哪一种类别的。   赛题数据由以下几个部分构成:训练集20w条样本,测试集A包括5w条样本,测试集B包括5w条样本。为了预防选手人工标注测试集的情况,我们将比赛数据的文本按照字符级别进行了匿名处理。处理后的赛题训练数据如下: labeltext657 44 66 56 2 3 3 37 5 41 9 57 44 47 45 33 13 63 58 31 17 47 0 1 1 69 26 60 62 15 21 12 49 18 38 20 50 23 57 44 45 33 25 28 47 22 52 35 30 14 24 69 54 7 48 19 11 51 16 43 26 34 53 27 64 8 4 42 36 46 65 69 29 39 15 37 57 44 45 33 69 54 7 25 40 35 30 66 56 47 55 69 61 10 60 42 36 46 65 37 5 41 32 67 6 59 47 0 1 1
  • NNLM 的 tensorflow-1.14 实现
    原文链接拜上镇贴:https://www.jmlr.org/papers/volume3/bengio03a/bengio03a.pdf NNLM 的用法思路:输入句子序列,预测下一个单词(英文)或者字(中文)的一种语言模型。 操作步骤如图有如下(这里用英文句子为例,中文类似): 输入层:分词,单词索引互相映射,将目标单词当作标签,上文的前 n-1 个单词作为输入 投影层:在投影层中,在 V*m 的词向量中进行 look_up ,其中 V 是词典的大小,而 m 是词向量维度。C 中每一行作为词的分布式表示,每一个单词都经过表 C 的转化变成一个词向量。n-1 个词向量首尾相接的拼起来,转化为 (n-1)*m 的空间向量矩阵。 隐藏层:根据公式进行计算 hidden = tanh(d+X*H) ,此层为 tanh 的非线性全连接层,H 和 d 可以理解为隐藏层的权重参数和偏置参数。 输出层:根据公式进行计算 y=b+X*W+ hidden*U ,此层为 softmax 输出层,根据概率大小可以得到相应的预测单词,U 是输出层参数,b 是输出层偏置。W 是词向量直接连到输出通路的参数,但是矩阵并不是必要的,可以为 0 。 import tensorflow as tf import numpy as np sentences = ['i like damao','i hate meng
  • 基于Java的文本相似度计算
    目录 1. 前言1.1 开发环境:1.2 初步设想1.3 参考资料 2. HanLP2.1 在Java中使用HanLP库2.2 分词函数 3. 双文本对比3.1 步骤分解3.2 完整代码 1. 前言 最近在做一个基于SSM的Web项目,其中有一项功能是 对相似文本进行合并 ,其中涉及一个文本间相似度计算的问题。在此将实现过程记录下来。 1.1 开发环境: 名称版本操作系统Win10 X64JDK1.8.0_144InteIliJ IDEA2020.1Tomcat9.0.29 1.2 初步设想 开始前有三个技术问题待解决 : 第一个问题是如何衡量文本的相似性。拟采用余弦相似性的方法。余弦相似度的计算单元是向量,因此第二个问题是如何将文本转换为向量。第三个问题是如何将一对一比较转换为多对多比较,按相似度将语料库中的多个文本进行相似度聚类。(这个问题并没有得到解决) 1.3 参考资料 CSDN博客 – Java 实现计算文本相似度 (使用余弦定理) : 本文许多代码是参考这篇博客里的。这篇博客的内容感觉有好多篇与它类似,我也不知道找的是不是原版…CSDN博客 – JAVA-简单实现文本相似度计算-余弦相似度 : 这篇博文提供了一个不使用 HanLP 库进行分词的简单案例,是基于字进行分割的。 2. HanLP Han Language Processing 是一个自然语言处理工具包
  • 图解Transformer(完整版)!
    审稿人:Jepson,Datawhale成员,毕业于中国科学院,目前在腾讯从事推荐算法工作。 结构总览 前言 本文翻译自http://jalammar.github.io/illustrated-transformer,是笔者看过的把 Transformer 讲解得最好的文章。这篇文章从输入开始,一步一步演示了数据在 Transformer 中的流动过程。由于看过一些中文翻译的文章,感觉不够好,所以我自己翻译了一个版本,在一些难以直译的地方,我加入了一些原文没有的文字说明,来更好地解释概念。另外,我添加了一些简单的代码,实现了一个基本的 Self Attention 以及 multi-head attention 的矩阵运算。 Transformer 依赖于 Self Attention 的知识。Attention 是一种在深度学习中广泛使用的方法,Attention的思想提升了机器翻译的效果。如果你还没学习 Attention,请查看这篇 Attention 的精彩讲解:https://zhuanlan.zhihu.com/p/265182368。 2017 年,Google 提出了 Transformer 模型,用 Self Attention 的结构,取代了以往 NLP 任务中的 RNN 网络结构,在 WMT 2014 Englishto-German 和 WMT 2014
  • embedding
    不是做NLP方向对这方面之前也并不了解,但本科学习过文本挖掘课程,在数据挖掘的时候偶尔会涉及到对本文特征的处理,只好趁着机会再学习总结下。 embedding 简单来说,embedding就是用一个低维的向量表示一个物体,可以是一个词,或是一个item(商品,或是一个电影等等)。这个embedding向量的性质是能使距离相近的向量对应的物体有相近的含义,比如 Embedding(复仇者联盟)和Embedding(钢铁侠)之间的距离就会很接近,但 Embedding(复仇者联盟)和Embedding(乱世佳人)的距离就会远一些。 除此之外Embedding甚至还具有数学运算的关系,比如Embedding(马德里)-Embedding(西班牙)+Embedding(法国)≈Embedding(巴黎) 从另外一个空间表达物体,甚至揭示了物体间的潜在关系,上次体会这样神奇的操作还是在学习傅里叶变换的时候,从某种意义上来说,Embedding方法甚至具备了一些本体论的哲学意义。 言归正传,Embedding能够用低维向量对物体进行编码还能保留其含义的特点非常适合深度学习。在传统机器学习模型构建过程中,我们经常使用one hot encoding对离散特征,特别是id类特征进行编码,但由于one hot encoding的维度等于物体的总数,比如阿里的商品one hot
  • 自然语言处理(NLP):23 Word2Vec词向量研究以及实践
    本文主要同大家分享word2vec原理以及应用,通过文本相似度和新闻文本分类为案例进行展开,最后对词向量技术发展进行简述。 作者:走在前方 博客:https://wenjie.blog.csdn.net/ 专注于文本分类、关键词抽取、文本摘要、FAQ 问答系统、对话系统语义理解 NLU、知识图谱等研究和实践。结合工业界具体案例和学术界最新研究成果实现 NLP 技术场景落地。 本次分享主要内容 词向量以及相关应用介绍 NLP常见的任务词离散化表示和分布式表示词相似性分析以及词嵌入可视化 词向量知识理论介绍 NNLM模型和word2vec 模型fastText 词向量以及文本分类原理 pytorch 工具构建word2vec 模型 词向量的概念用 skip-gram 模型训练词向量PyTorch dataset 和 dataloader定义 PyTorch 模型学习 torch.nn 中常见的 Module Embedding 学习常见的 PyTorch operations bmmlogsigmoid 保存和读取 PyTorch 模型 gensim 工具构建word2vec 模型 数据分词处理词向量模型训练以及性能功能验证相似性服务演示以及数据可视化word2vec 词向量可视化 案例分享 新闻相似推荐新闻文本分类 展望未来:词向量技术拓展 词向量历史发展(word2vec->
  • 深度学习笔记:前向网络
    导读:本文来自朱鉴老师整理的深度学习笔记节选(完整版《深度学习笔记》,可以关注本文公众号,后台回复“DL笔记”获取),第10.1节 · 前向网络,本节首先回顾前向网络结构,在此基础上进一步回顾该类网络架构在语言模型、排序问题及推荐问题上的应用。▌10.1.1 网络结构前向神经网络由若干层隐藏层和一层输出层构成,网络中层和层之间为全连接方式,连接权重参数及偏执权值即为要训练的参数。隐藏层由若干神经元组成,每层一般采用统一的激活函数,实际上应用中所有隐藏层常常采用统一的激活函数。训练过程中在输出层之后加入损失函数即可进行网络中涉及参数的训练。如下为一个包含两层隐藏层的前向网络:输入层为向量 x∈R4,第一层隐藏层输出向量为 h(1)∈R5,输入层和隐藏层间的连接权重参数为 W(1)∈R5×4,对应的偏执项为 b(1)∈R5,第二层隐藏层输出向量为 h(2)∈R3, 和前一层的连接权重参数为 W(2)∈R3×4,对应的偏执项为 b(2)∈R3,输出层输出向量为 yˆ,和前一层的连接权重参数为 W(3)∈R2×3,对应的偏执项为 b(3)∈R2。假设隐藏层统一采用 ReLU 激活函数,输出层采用 Identity 映射,若问题为分类问题,则对输出层统一应用 Softmax 归一化操作,则输出 yˆi 为当前输入输入属于该类别的概率。该网络结构对应的数据变换如下
  • 答案选择|语义匹配任务目前表现最好的几个模型
    公众号关注 “ML_NLP” 设为 “星标”,重磅干货,第一时间送达! 来自 | 知乎 地址 | https://zhuanlan.zhihu.com/p/39920446 作者 | 是江晚晚呀 编辑 | 机器学习算法与自然语言处理公众号 本文仅作学术分享,若侵权,请联系后台删文处理 Answer selection是QA中的一个重要任务。基本定义是:给出问题q和该问题的答案候选池 (s是池大小),目标是从答案池中找到可以准确回答问题最佳答案候选 。这项任务的主要挑战是正确的答案可能不会直接与问题共享词汇单位。相反,它们可能只是在语义上相关。此外,答案有时很嘈杂,并且包含大量不相关的信息。 text matching是nlp中一个重要的基础问题,nlp中的许多任务都可以抽象为文本匹配任务。文本匹配的算法,主要用于搜索引擎、问答系统等,主要是为了找到与目标文本最相关的文本,比如在问答系统中找到和问题最相关的答案,在搜索引擎中找到与搜索框中关键词最相关的网页等。 解决answer selction的一般思路是:首先用LSTM或者CNN的神经编码器学习问题和答案的表示,然后进行text matching,将任务转换为分类或者learning-to-rank问题。神经排序模型在QA中对候选答案进行排序以回答问题,核心是问答表示之间交互函数的设计。 下表是answer
  • pytorch实现lstm分类模型
    教程原文在这里Tutorial,这篇文章中用LSTM实现了一个简单的词类标注模型。下面是一些具体的解析: # Author: Robert Guthrie import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim torch.manual_seed(1) # 引用库函数 我们首先了解如何初始化一个nn.LSTM实例, 以及它的输入输出。初始化nn.LSTM实例, 可以设定的参数如下: 常用的是前两个,用来描述LSTM输入的词向量维度和输出的向量的维度(与hidden state相同),其中num_layer指的是这样的结构: 这种称作stacked LSTM,如上就是两层LSTM堆叠起来。bi-direction指的是双向,双向的LSTM会从正反两个方向读句子,依次输入词向量, 两个方向的hidden state也并不是公共的,如下图: 对应到下面代码的第一行,就是创建了一个输入输出的维度均为3、单层单向的LSTM网络。 lstm = nn.LSTM(3, 3) # Input dim is 3, output dim is 3 inputs = [torch.randn(1, 3) for _ in range(5)] # make a