devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【论文实现】一篇Sigkdd的弹幕分析论文的python实现【LDA 实践者】

作者：知新_RL | 2024-02-29 03:21:06

赞

踩

一篇sigkdd的弹幕分析论文的python实现 【lda 实践者】

【论文实现】一篇Sigkdd的弹幕分析论文的python实现 【LDA 实践者】

Author : Jasper Yang
School : Bupt

warning : 此篇文章基于较为熟悉GibbsLDA++的源码的前提下阅读。另外，这篇文章是我的一个很不成熟的笔记，里面的很多东西和我实现的最终版本的TPTM（这篇论文的模型）已经大相径庭了，所以这篇文章就当成一篇简单的记录吧，我还是放在我的blog里，不太想丢弃。-_-

论文link

在开始之前，我想提前说明一下，这篇文章是我实现了基于用户喜好和评论的前后影响的改进LDA，因为实验室在做弹幕分析这方面的研究，就找到了这篇A类会议的文章，本来找他们要源码的，但是他们一作并不理我。。。然后我只好自己实现了。

由于是第一次写这类文章，不知道在逻辑上表达的清不清楚，~.~，望有看的各位给点建议，哈。

怎么实现

first of first
  1.     from scipy.special import digamma
  2.     import eulerlib
  3.     import numpy as np
  4.     import math
  5.     from scipy.special import gamma
  6.     import jieba
  7.     import pandas as pd
  8.     from scipy import stats

以上是本文所需库。

let's begin(前期准备工作)

首先是处理数据

数据来源：bilibili（爬虫爬取）

数据格式如下。

  1.                                                                                                     <?xml version="1.0" encoding="UTF-8"?><i>   <chatserver>chat.bilibili.com</chatserver><chatid>1007373</chatid><mission>0</mission><maxlimit>8000</maxlimit><source>e-r</source><ds>274694331</ds><de>3034701550</de><max_count>8000</max_count>
  2.                                                                                                     <d p="72.409,1,25,16777215,1375542175,0,7526c714,274694331">我来组成弹幕..................</d>
  3.                                                                                                     
  4. <d p="33.551,1,25,16777215,1375543533,0,925384b2,274711742">大佬系边 </d>
  5.  
  6. <d p="117.977,1,25,16777215,1375543631,0,925384b2,274712904">甘嗨假噶 </d>
  7.  
  8. <d p="134.849,1,25,16777215,1375547487,0,D3dfe4a5,274755463">呢个日文..一个字都听唔明</d>
  9. ...

下面写了段代码解析获得上面的用户id以及每个用户的评论。
最后形成一个所有评论的列表以及每个用户对应其评论的字典。

  1.     user = {}
  2.     comments = []
  3.     split_num = 10 # 分割一部电影为几个片段
  4.     
  5.     # 数据和停用词
  6.     danmu = open('danmu/1007373.xml')
  7.     stopwords = {}.fromkeys([ line.rstrip().decode('gbk') for line in open('stopwords.txt') ])
  8.     # 读取文件，分析后存储到 user 和 comments
  9.     for line in danmu.readlines()[:-1]:
  10.         start = line.find('p=')
  11.         stop = line.find('">')
  12.         sub1 = line[start+3:stop]
  13.         time = sub1.split(',')[0]
  14.         sub1 = sub1.split(',')[6]
  15.         start = line.find('">')
  16.         stop = line.find('</d>')
  17.         sub2 = line[start+2:stop].decode('utf-8')
  18.         comments.append((float(time),sub2))
  19.         temp = []
  20.         if not user.has_key(sub1) :
  21.             temp.append(sub2)
  22.             user[str(sub1)] = temp
  23.         else:
  24.             user[str(sub1)].append(sub2)

经过以上处理后，我们还需要分片，我这里默认分割成十份。

  1.     # 统计user的个数 , 现在统计的是这个文档里的user，后期要做成对所有文档的统计量，还要能支持增量
  2.     user_num = len(user)
  3.     
  4.     # comments的数量
  5.     comments_num = len(comments)
  6.             
  7.     # 排序，分割comments ---> shots
  8.     comments = sorted(comments)
  9.     spli = (comments[-1][0]-comments[0][0])/split_num
  10.     shots = []
  11.     for i in range(10):
  12.         shots.append([x[1] for x in comments if x[0] > i*spli and x[0] <= (i+1)*spli ])

分割之后就是分词，我这里用的是python版的jieba，效果很一般，以后再更新。

注意：这里的切词我分成了两个部分。因为在文中认为片段(shot)和片段之间有时间上的影响，然后每个片段里的每一个comment之间有时间上的影响。但是不同的片段之间的comment是没有关系的。

  1. def cut_word(x):
  2.     words = jieba.cut(x, cut_all=False)
  3.     final = []
  4.     for word in words:
  5.         if word not in stopwords:
  6.             final.append(word)
  7.     return final
  8.  
  9. def null(l):
  10.     return len(l) > 0 or l[0] == ' '
  11.  
  12. for i in range(split_num):
  13.     shots[i] = map(cut_word,shots[i])
  14.     shots[i] = filter(null,shots[i])

上面的代码对每一个shot里面的所有comment进行切词。

准备工作到此为止~

real work

由于这是我第一次还原论文的实现内容，一开始也是一头雾水，无从下手。慢慢多看了几遍公式，我发现了一些规律。

这里写图片描述

这里写图片描述

了解LDA的同学对上面的一系列定义应该不陌生。
这是一个我们要实现的所有的矩阵的描述。

从头开始，对每一个用户生成一个用户对应主题的矩阵（$x_u$）。每一个用户都有一个自己的$sigma_u^2$。但是，由于我们是在初步实验阶段，我就写了个文件，里面存储所有的$sigma^2$值并且都为0.1。

  1.     # 制造假的sigma文件
  2.     user_num = len(user)
  3.     f = open('sigma_u_t.csv','w')
  4.     f.write(',user')
  5.     for i in range(split_num*10):
  6.         f.write(',topic'+str(i))
  7.     f.write('\n')
  8.     for key in user.keys():
  9.         f.write(','+key)
  10.         for j in range(split_num*10):
  11.             f.write(',0.1')
  12.         f.write('\n')
  13.  
  14.  
  15.     # 每一个用户的user-topic分布
  16.     # sigma_u_t 是每个用户对于每一个topic的sigma值
  17.     # 从文件里面读取每一个用户的每一个topic的sigma值
  18.     # 每一行一个用户 (顺序就是下面生成的 user_ 中的顺序)
  19.     user_sigma = pd.read_csv('sigma_u_t.csv')
  20.     user_sigma = user_sigma.drop(['Unnamed: 0'],1)
  21.     user_sigma.fillna(0.1)
  22.     
  23.             
  24.     # 利用上面的用户对应评论的字典 make 一个 dataframe
  25.     user_ = pd.DataFrame()
  26.     temp1 = []
  27.     temp2 = []
  28.     for key in user.keys():
  29.         for i in range(len(user[key])):
  30.             temp1.append(key)
  31.             temp2.append(user[key][i])
  32.     user_['user'] = temp1
  33.     user_['comment'] = temp2

【后期的做法可以是去通过标签统计分析每一个用户对于主题的概率再去确定每一个用户的$sigma^2$值】

下面我们需要实现$lambda_s = N(m_{pre_s},sigma_sI_K)$。这里就会发现我们要先去实现$m_{pre_s}$

这里写图片描述

可以从文中读到这个$m_{pre_s}$就是当前的shot的之前所有的shot对其的影响值相加，具体怎么影响的公式用到了 exponential decay 。（其中$Delta(s,s^{'})$是两个shot之间的绝对差，我这里的实现是用cos，也就是余弦值）

因为comment的$Delta$和shot的$Delta$计算方式相近，我就在下面的实现中一起实现了。

实现 $Delta$

先讲下余弦值计算的原理：

  1. 一个简单的例子（后面第三部分是相对复杂的例子）：
  2.  
  3. 　　句子A：我喜欢看电视，不喜欢看电影。
  4.  
  5. 　　句子B：我不喜欢看电视，也不喜欢看电影。
  6.  
  7. 请问怎样才能计算上面两句话的相似程度？
  8. 基本思路是：如果这两句话的用词越相似，它们的内容就应该越相似。因此，可以从词频入手，计算它们的相似程度。
  9.  
  10. 第一步，分词。
  11.  
  12. 　　句子A：我/喜欢/看/电视，不/喜欢/看/电影。
  13.  
  14. 　　句子B：我/不/喜欢/看/电视，也/不/喜欢/看/电影。
  15.  
  16. 第二步，列出所有的词。
  17.  
  18. 　　我，喜欢，看，电视，电影，不，也。
  19.  
  20. 第三步，计算词频。
  21.  
  22. 　　句子A：我 1，喜欢 2，看 2，电视 1，电影 1，不 1，也 0。
  23.  
  24. 　　句子B：我 1，喜欢 2，看 2，电视 1，电影 1，不 2，也 1。
  25.  
  26. 第四步，写出词频向量。
  27.  
  28. 　　句子A：[1, 2, 2, 1, 1, 1, 0]
  29.  
  30. 　　句子B：[1, 2, 2, 1, 1, 2, 1]
  31.  
  32. 到这里，问题就变成了如何计算这两个向量的相似程度。
  33.  
  34. 使用余弦这个公式，我们就可以得到，句子A与句子B的夹角的余弦。

这里写图片描述

  1.  
  2. 余弦值越接近1，就表明夹角越接近0度，也就是两个向量越相似，这就叫余弦相似性。所以，上面的句子A和句子B是很相似的，事实上它们的夹角大约为20.3度。

从上面可以看出如果套用到我们的模型中，分成两类：

  1. 每个shot有一个词向量矩阵

  2. 每个comment有一个词向量矩阵

如下图。
左边是单词，右边是单词出现的次数。
map

因为我们是对一部视频也就是一篇文档处理，所以词向量可以是这篇文档里出现过的词。因此用下面的代码找出所有的词并存储成一个pandas的dataframe（使用这个的原因是处理起来很快而且方便）

  1. # 统计关键词及个数 （根据文件）
  2. def CountKey(fileName, resultName):
  3.     try:
  4.         #计算文件行数
  5.         lineNums = len(open(fileName,'rU').readlines())
  6.         # print u'文件行数: ' + str(lineNums)
  7.  
  8.         #统计格式 格式<Key:Value> <属性:出现个数>
  9.         i = 0
  10.         table = {}
  11.         source = open(fileName,"r")
  12.         result = open(resultName,"w")
  13.         
  14.         while i < lineNums:
  15.             line = source.readline()
  16.             line = line.rstrip()
  17.             # print line
  18.             
  19.             words = line.split(" ")  #空格分隔
  20.             # print str(words).decode('string_escape') #list显示中文
  21.             
  22.             #字典插入与赋值
  23.             for word in words:
  24.                 if word!="" and table.has_key(word):      #如果存在次数加1
  25.                     num = table[word]
  26.                     table[word] = num + 1
  27.                 elif word!="":                            #否则初值为1
  28.                     table[word] = 1
  29.             i = i + 1
  30.  
  31.         #键值从大到小排序 函数原型：sorted(dic,value,reverse)
  32.         dic = sorted(table.iteritems(), key = lambda asd:asd[1], reverse = True)
  33.         word_fre = pd.DataFrame(dic)
  34.         for i in range(len(dic)):
  35.             #print 'key=%s, value=%s' % (dic[i][0],dic[i][1])
  36.             result.write("<"+dic[i][0]+":"+str(dic[i][1])+">\n")
  37.         return word_fre
  38.         
  39.     except Exception,e:    
  40.         print 'Error:',e
  41.     finally:
  42.         source.close()
  43.         result.close()
  44.         # print 'END\n\n'
  45.  
  46.  
  47. f = open('comments.txt','w')
  48. for i in range(split_num):
  49.     for x in shots[i]:
  50.         for word in x:
  51.             f.write(word.encode('utf-8') + ' ')
  52.     f.write('\n')
  53.  
  54. word_fre = CountKey('comments.txt','comments_map')

最后得到的 word_fre 就是一个词频向量（全集），其实并不需要计算全集的词频。

  1.     0    1
  2. 0    好    120
  3. 1    哈哈哈    116
  4. 2    哈哈哈哈    72
  5. 3    吴妈    50
  6. 4    卧槽    48
  7. 5    神父    48
  8. 6    人    41
  9. 7    黑社会    37
  10. 8    靓坤    35
  11. 9    真的    34
  12. 10    死    33
  13. 11    叻    31
  14. 12    说    30
  15. 13    君    28
  16. 14    一个    25
  17. 15    太    23
  18. 16    想    22
  19. 17    大佬    20
  20. 18    卖    20
  21. 19    吴    20
  22. 20    坤    20
  23. 21    香港    19
  24. 22    樽    19
  25. 23    爆    19
  26. 24    古惑仔    18
  27. 25    2333333    17
  28. 26    233333    17
  29. 27    笑    16
  30. 28    可爱    16
  31. 29    李丽珍    16
  32. ...    ...    ...
  33. 1986    额滴    1
  34. 1987    痛    1
  35. 1988    死于    1
  36. 1989    递纸    1
  37. 1990    hahahahhahahah8    1
  38. 1991    扭    1
  39. 1992    扑    1
  40. 1993    却    1
  41. 1994    扛    1
  42. 1995    阿公    1
  43. 1996    头子    1
  44. 1997    交个    1
  45. 1998    对手    1
  46. 1999    解构    1
  47. 2000    改一改    1
  48. 2001    惹不起    1
  49. 2002    湖地    1
  50. 2003    把持    1
  51. 2004    布吉岛    1
  52. 2005    傻仔    1
  53. 2006    莫名    1
  54. 2007    ′    1
  55. 2008    ‵    1
  56. 2009    陸仔    1
  57. 2010    兴趣    1
  58. 2011    祛湿    1
  59. 2012    君比靓    1
  60. 2013    培养    1
  61. 2014    不卡    1
  62. 2015    留学    1

我的构思是这样的。
构建每一个shot的词向量，就去统计每个shot里面的每个词的词频，没在该shot里出现过的但是在全集有的为0，词向量的顺序就和上面的 word_fre 一样，这样后面的计算直接就是处理两个dataframe就可以了。

同理，对每一个comment也是一样的。每一个comment都有一个词向量dataframe（这里会造成对内存的大量使用，但是计算起来快）

  1. # 计算每一个shot里面的所有的单词的词频 ------->   缺点：执行速度实在太慢了，后期需要修改
  2. result_s = []
  3. for i in range(split_num):
  4.     shot_word_fre = word_fre.copy()
  5.     shot_word_fre['time'] = 0
  6.     for x in shots[i]:
  7.         for word in x:
  8.             index = shot_word_fre[word_fre[0] == word.encode('utf-8')].index
  9.             shot_word_fre['time'][index] = shot_word_fre['time'][index] + 1
  10.     shot_word_fre = shot_word_fre.drop(1,1)
  11.     result_s.append(shot_word_fre)
  12.     
  13. # 计算每一个comment的词频向量  -----------> 现在的办法是每个 comment 都有一个完整的词向量，便于后面的计算，问题是这样很占内存资源
  14. # 按照每一个shot分片后内部的comment之间的delta计算
  15. # result_c = []
  16. # for i in range(split_num):
  17. #     temp = []
  18. #     for j in range(len(shots[i])):
  19. #         shot_word_fre = word_fre.copy()
  20. #         shot_word_fre['time'] = 0
  21. #         for x in shots[i][j]:
  22. #             for word in x:
  23. #                 index = shot_word_fre[word_fre[0] == word.encode('utf-8')].index
  24. #                 shot_word_fre['time'][index] = shot_word_fre['time'][index] + 1
  25. #         shot_word_fre = shot_word_fre.drop(1,1)
  26. #         temp.append(shot_word_fre)
  27. #     result_c.append(temp)
  28.  
  29.  
  30. # 计算每一个comment的词频向量  -----------> 现在的办法是每个 comment 都有一个完整的词向量，便于后面的计算，问题是这样很占内存资源
  31. # 不按照每一个shot分片后内部的comment之间的delta计算，所有的comment进行计算
  32. result_c = []
  33. for i in range(split_num):
  34.     for j in range(len(shots[i])):
  35.         shot_word_fre = word_fre.copy()
  36.         shot_word_fre['time'] = 0
  37.         for x in shots[i][j]:
  38.             for word in x:
  39.                 index = shot_word_fre[word_fre[0] == word.encode('utf-8')].index
  40.                 shot_word_fre['time'][index] = shot_word_fre['time'][index] + 1
  41.         shot_word_fre = shot_word_fre.drop(1,1)
  42.         result_c.append(shot_word_fre)

有了词向量之后就可以计算$Delta$了
我这里是将所有的$Delta$都计算出来了，做成了一个下三角矩阵，具体为什么是下三角矩阵仔细想想就知道了。这样做的好处是我后面使用$Delta(s,s^{'})$直接就可以变成delta_s(i,j)或是delta_c(i,j)。

p.s. 我做了修改，之前我理解的是每个shot里面的所有的comment之间计算$Delta$值，但是后来我想想不是这样的，对于comment应该还是所有的comment前后进行计算。因此，上面的result_c要改，这里的delta_c也要改，我把原先的代码注释掉了。

  1. # 计算delta<s,_s> : 这里用的是词频向量 余弦值    -----> 下三角矩阵，后面方便计算
  2. # 从后面的shot往前计算
  3. delta_s = np.zeros((split_num,split_num))
  4. seq = range(split_num)
  5. # 修改 time 的数据类型 to float64
  6. for shot in result_s:
  7.     shot.time = shot.time.astype('float64')
  8.  
  9. seq.reverse()
  10. for i in seq:
  11.     for j in range(i):
  12.         numerator = np.sum(result_s[i].time*result_s[j].time)
  13.         denominator = pow(np.sum(pow(result_s[i].time,2)),0.5)*pow(np.sum(pow(result_s[j].time,2)),0.5)
  14.         if denominator != 0:
  15.             cos = numerator/denominator
  16.         else:
  17.             cos = 0
  18.         delta_s[i][j] = cos
  19.         
  20.  
  21. # 计算delta<c,_c> : 这里用的是词频向量 余弦值    -----> 下三角矩阵，后面方便计算
  22. # 从后往前
  23. # 这里是按照每个shot分开然后计算里面的comment
  24. # seq = range(len(result_c))
  25. # # 修改 time 的数据类型 to float64
  26. # for i in seq:
  27. #     for comment in result_c[i]:
  28. #         comment.time = comment.time.astype('float64')
  29.  
  30. # # 创建每个shot的一个矩阵，用list存储
  31. # delta_c = []
  32. # for i in seq:
  33. #     length = len(result_c[i])
  34. #     delta_c_temp = np.zeros((length,length))
  35. #     delta_c.append(delta_c_temp)
  36.  
  37. # for i in seq:
  38. #     seq2 = range(len(result_c[i]))
  39. #     seq2.reverse()
  40. #     for j in seq2:
  41. #         for k in range(j):
  42. #             numerator = np.sum(result_c[i][j].time*result_c[i][k].time)
  43. #             denominator = pow(np.sum(pow(result_c[i][j].time,2)),0.5)*pow(np.sum(pow(result_c[i][i].time,2)),0.5)
  44. #             if denominator != 0:
  45. #                 cos = numerator/denominator
  46. #             else:
  47. #                 cos = 0
  48. #             delta_c[i][j][k] = cos
  49.             
  50.     
  51. # 计算delta<c,_c> : 这里用的是词频向量 余弦值    -----> 下三角矩阵，后面方便计算
  52. # 从后往前
  53. # 这里是不按照每个shot分开然后计算里面的comment
  54. seq = range(len(result_c))
  55. # 修改 time 的数据类型 to float64
  56. for i in seq:
  57.     result_c[i].time = result_c[i].time.astype('float64')
  58.  
  59. # list存储
  60. delta_c = np.zeros((len(result_c),len(result_c)))
  61.  
  62. for i in seq:
  63.     for k in range(i):
  64.         numerator = np.sum(result_c[i].time*result_c[k].time)
  65.         denominator = pow(np.sum(pow(result_c[i].time,2)),0.5)*pow(np.sum(pow(result_c[j].time,2)),0.5)
  66.         if denominator != 0:
  67.             cos = numerator/denominator
  68.         else:
  69.             cos = 0
  70.         delta_c[i][k] = cos

由于第一个shot没有在它之前的shot，所以第一个shot的$m_{pre_s}$等于零。
接下来的每个$m_{pre_s}$都与之前的有关，并且是针对每一个topic的，所以$m_{pre_s}$应该是一个矩阵（这点想清楚才能编程）

  1. # 有了上面的矩阵后，计算论文中提到的 M_pre_s 以及 M_pre_c
  2. # 需要两个衰减参数 gamma_s 以及 gamma_c
  3. # M_pre_s 比较好计算，M_pre_c 比较复杂一点，因为涉及到了每一个shot
  4. gamma_s = 0.5 # 我自己设的
  5. gamma_c = 0.3 # 论文中做实验得到的最好的值
  6. M_pre_s = np.zeros((split_num,total_topic))  # 行：shot个数    列：topic个数
  7. lambda_s = np.zeros((split_num,total_topic))
  8. sigma_s = 0.1 # 应该是每个片段的都不一样，但是这里我认为其实每个片段的topic分布没有统计可能性，不合理，都设成一样的了
  9.  
  10. # 先初始化 M_pre_s[0] 以及 lambda_s[0]
  11. mu = 0 # 初始的 M_pre_s[0] 都是0
  12. s = np.random.normal(mu,sigma_s,total_topic) # 不知道这个做法对不对，用正态生成x坐标，再用pdf去生成y值
  13. lambda_s[0] = st.norm(mu, sigma_s).pdf(s)
  14.  
  15. # 从 第1的开始
  16. for i in range(1,split_num):
  17.     for topic in range(total_topic): # 先循环topic
  18.         for j in range(i):
  19.             numerator = np.exp(-gamma_s*delta_s[i][j])*lambda_s[j][topic]
  20.             denominator = np.exp(-gamma_s*delta_s[i][j])
  21.         M_pre_s[i][topic] = numerator/denominator
  22.         s = np.random.normal(M_pre_s[i][topic],sigma_s,1)
  23.         lambda_s[i][topic] = st.norm(M_pre_s[i][topic], sigma_s).pdf(s)

需要提一句，我里面可能会有些变量没定义就使用了，毕竟这是我的一个心路历程的总结，不是完整的源代码，如果需要看源代码可以去我的 Github 上看。

接下来就是计算 $m_{pre_c}$和$pi_c$了，处理起来会比较复杂一点，因为里面涉及了评论的用户以及用户对应的topic分布。这时候如果只是匹配的话程序会慢到死的，我的做法就是先处理出一张大表（dataframe）之后，每条评论以及对应的user以及对应的topic分布就可以很轻松快速地查到了。

  1. # 总的topic个数，我在这里才填了total_topic这个参数，是有点晚了，不过，我之前在这里还遇到了一些问题，我以为是每个shot里面有固定的topic数，然后总的topic数是相乘的结果，后来经过一番认真思考，我才悔悟到原LDA中的topic数是固定的，然后不管你输入了多少文档，这个也应该一样，只不过文档变成了shot。
  2. total_topic = 10
  3.  
  4.  
  5. # 每一个用户的user-topic分布
  6. # sigma_u_t 是每个用户对于每一个topic的sigma值
  7. # 从文件里面读取每一个用户的每一个topic的sigma值
  8. # 每一行一个用户 (顺序就是下面生成的 user_ 中的顺序)
  9. user_sigma = pd.read_csv('sigma_u_t.csv')
  10. user_sigma = user_sigma.drop(['Unnamed: 0'],1)
  11. user_sigma.fillna(0.1)
  12.  
  13.         
  14. # 利用上面的用户对应评论的字典 make 一个 dataframe
  15. user_ = pd.DataFrame()
  16. temp1 = []
  17. temp2 = []
  18. for key in user.keys():
  19.     for i in range(len(user[key])):
  20.         temp1.append(key)
  21.         temp2.append(user[key][i])
  22. user_['user'] = temp1
  23. user_['comment'] = temp2
  24.  
  25.  
  26. # 处理得到一个大表，里面包括所有评论以及评论的人，和每个人对应的所有的topic的sigma值
  27. # 这里处理之后好像有点问题，有些用户没有，下面我直接就都填充0.1了
  28. comment_per_shot = []
  29. for i in range(split_num):
  30.     temp = pd.DataFrame(com[i])
  31.     u = []
  32.     tem = pd.DataFrame()
  33.     for j in range(len(temp)):
  34.         user_id = user_[user_.comment == temp[0][j]].iloc[0][0]
  35.         u.append(user_id)
  36.         a = user_sigma[user_sigma.user == user_id].iloc[:,1:]
  37.         tem = [tem,a]
  38.         tem = pd.concat(tem)
  39.     tem = tem.reset_index().drop(['index'],1)
  40.     temp['user'] = pd.DataFrame(u)
  41.     temp = temp.join(tem)
  42.     comment_per_shot.append(temp)
  43.  
  44. # 所有的 comment 的一个 dataframe ,comment-user_id-topic0,1,2...99 ，后面的topic分布是user_id的
  45. comment_all = pd.concat(comment_per_shot).reset_index().drop('index',1)
  46. # 给那些没有topic分布的用户填充0.1 ----> 缺失值（就是生成用户的topic分布表没有生成全）
  47. comment_all = comment_all.fillna(0.1) # 没有topic分布的都填充为0.1
  48. comment_all = comment_all.rename(columns={0:'comment'})

上面的 comment_all 的结构基本上就是

  1. index - comment - user - user's topic distribution(列数是总的topic个数)

这结构下面我还会更新用作更方便的计算。
然后有个这个 dataframe 之后我们就可以计算 $m_{pre_c}$和$pi_c$

  1. # 生成 pi_c 和 M_pre_c 不同于上面，因为这里是对每个shot的面的comment进行操作
  2. # 先初始化 M_pre_c[0] 和 第0个 shot 里的第一个 comment 对应的 pi_c[0]
  3. M_pre_c = np.zeros((len(comment_all),total_topic))  # 行：shot个数    列：topic个数
  4. pi_c = np.zeros((len(comment_all),total_topic))
  5. for i in range(total_topic):
  6.     pi_c[0][i] = lambda_s[0][i]*comment_all.iloc[0][i+2] + M_pre_c[0][i]
  7.  
  8. start = 0 # shot 之间的位移
  9. for q in range(split_num):
  10.     if q == 0:
  11.         for i in range(1,len(com[q])):
  12.             for topic in range(total_topic): # 先循环topic
  13.                 numerator = 0
  14.                 denominator = 0
  15.                 for j in range(i):
  16.                     numerator += np.exp(-gamma_c*delta_c[i][j])*pi_c[j][topic]
  17.                     denominator += np.exp(-gamma_c*delta_c[i][j])
  18.                 M_pre_c[i][topic] = numerator/denominator
  19.                 pi_c[i][topic] = lambda_s[q][topic]*comment_all.iloc[i][topic+2] + M_pre_c[i][topic]
  20.         start += len(com[q])
  21.     else:
  22.         for i in range(start,start+len(com[q])):
  23.             for topic in range(total_topic): # 先循环topic
  24.                 numerator = 0
  25.                 denominator = 0
  26.                 for j in range(i):
  27.                     numerator += np.exp(-gamma_c*delta_c[i][j])*pi_c[j][topic]
  28.                     denominator += np.exp(-gamma_c*delta_c[i][j])
  29.                 M_pre_c[i][topic] = numerator/denominator
  30.                 pi_c[i][topic] = lambda_s[q][topic]*comment_all.iloc[i][topic+2] + M_pre_c[i][topic]
  31.         start += len(com[q])

基本任务上面就完成了，下面的是两个更新公式的实现（下面两幅图），看上去只有两个，但是实现起来特别困难，而且还要考虑时间复杂的问题。

这里写图片描述

这里写图片描述

在我第一次实现出来的版本需要两个多小时的执行时间（-_-|），后来进行了 dataframe的更新以及采用多个线程池的方式提高了运行的速度。

最后的最后，我终于知道为什么了，我把topic设置的太多了，我认为一部电影分片10片，每一片里面有10个topic，这样一部电影里面就有了100个topic，计算起来时间很久，这段心路历程在上面的total_topic这个变量定义的地方我有详述了，所以在优化之后，我修改了topic的总数

下面我直接贴出我优化后的版本，再去讲怎么优化的。

下面代码的前半段是生成一些需要的矩阵，当然，我这里做成了 dataframe。

注意：下面的代码很长很长，但是，我做了很多的注释，我相信能够解释的清楚。

里面涉及了 GibbsLDApy （我模仿 GibbsLDA++ 实现的python版本）的内容。大家也可以去看看我实现的这个版本 GibbsLDApy，顺便点点赞 ：）。后面我会整合所有代码形成新的 danmuLDA 做成分支。

  1. # 生成 trndocs.dat 文件
  2. # 该文件就是视频的剪切 -----> 分成了 split_num 份数，每一份代表一篇文档
  3. f = open('test_data/trndocs.dat','w')
  4. f.write(str(split_num)+'\n')
  5. for i in range(split_num):
  6.     for j in range(len(shots[i])):
  7.         for k in range(len(shots[i][j])):
  8.             f.write(shots[i][j][k].encode('utf-8')+' ')
  9.     f.write('\n')
  10.  
  11.  
  12. import time # 用来记录代码执行时间
  13. # 欧拉函数的定义
  14. eur = eulerlib.numtheory.Divisors(10000) # maxnum
  15.  
  16.  
  17. #　执行 model 初始化
  18. #  因为现在还是实验阶段，我没有和原LDA整合成一个完整的LDA，所以我这里用了 GibbsLDApy的初始化model的功能
  19. argv = ['-est', '-alpha', '0.5', '-beta', '0.1', '-ntopics', '100', '-niters',
  20.         '1000', '-savestep', '100', '-twords', '20', '-dfile', 'trndocs.dat', '-dir', 'test_data/',
  21.         '-model', 'trnmodel']
  22. pmodel = Model()
  23. pmodel.init(len(argv),argv)
  24.  
  25.  
  26. # 将 comment_all 升级成一个新的大表 comment_all_sort 结构为 {comment,user_id,user_id的topic,该comment属于的shot的topic分布},有了这个表，后面的处理会很方便
  27. a1 = pd.concat([comment_all,pd.DataFrame(M_pre_c)],axis=1)
  28. temp = []
  29. for i in range(split_num):
  30.     for j in range(len(shots[i])):
  31.         t = pd.DataFrame(lambda_s)[i:i+1]
  32.         t['shot'] = i
  33.         t['com'] = j
  34.         temp.append(t)
  35. a2 = pd.concat(temp)
  36. a2 = a2.reset_index().drop('index',1)
  37. comment_all_sort = pd.concat([a1,a2],axis=1)
  38. comment_all_sort = comment_all.sort_values('user') # 按照 user 排序
  39.  
  40.  
  41. # 生成 user-topic 分布的 dataframe
  42. x_u_c_t = np.zeros((len(comment_all_sort),total_topic))
  43. for i in range(len(comment_all_sort)):
  44.     for topic in range(total_topic):
  45.         s = np.random.normal(mu,comment_all_sort.icol(topic+2)[i],1)
  46.         x_u_c_t[i][topic] = st.norm(mu, comment_all_sort.icol(topic+2)[i]).pdf(s)
  47. user_id = comment_all_sort.drop_duplicates('user')['user'].reset_index().drop('index',1)
  48. x_u_c_t = user_id.join(pd.DataFrame(x_u_c_t))
  49.  
  50.         
  51. def lgt(y):
  52.     return math.log(1+math.exp(y))
  53. def dlgt(y):
  54.     return 1/((1+math.exp(y))*np.log(10))
  55.  
  56. word2id = pd.read_csv('test_data/wordmap.txt',sep=' ') # 读取单词对应id的表
  57. column = list(word2id)[0]   # 这个是因为第一行是单词的个数，会变成index，下面转换成字典后出现二级索引，所以做了处理
  58. word2id = word2id.to_dict()
  59. yita_lambda_s = lambda_s.copy()
  60.  
  61. # 线程函数 --> 计算 yita_lambda_s
  62. def calculate_lambda_s(shot,start):
  63.     for topic in range(total_topic):
  64.         result = 0
  65.         lam_s = lambda_s[shot][topic]
  66.         for comment in range(len(shots[shot])):
  67.             u = x_u_c_t[x_u_c_t.user == comment_all.iloc[comment+start][topic+1]]
  68.             x_u = u.iloc[0][topic+1]
  69.             m_pre_c = M_pre_c[comment+start][topic]
  70.             t1 = x_u*dlgt(x_u*lam_s+m_pre_c)
  71.             t2 = 0
  72.             for t in range(total_topic):
  73.                 t2 += lgt(comment_all.iloc[comment+start][t+2]*lam_s+M_pre_c[comment+start][t])
  74.             t3 =t2
  75.             t2 = eur.phi(t2)
  76.             t3 = eur.phi(t3+len(shots[shot][comment]))
  77.             n_tc = 0
  78.             for word in shots[shot][comment]:
  79.                 word = word.encode('utf-8')
  80.                 if word != ' ' :
  81.                     try:
  82.                         num = word2id[column][word]
  83.                         n_tc += pmodel.nw[num][topic]
  84.                     except Exception,e:  
  85.                         print Exception,":",e
  86.             t4 = eur.phi(lgt(x_u*lam_s+m_pre_c) + n_tc)
  87.             t5 = eur.phi(lgt(x_u*lam_s+m_pre_c))
  88.         result += t1 * (t2 - t3 + t4 - t5)
  89.         yita_lambda_s[shot][topic] = -(lam_s+M_pre_s[shot][topic])/(lam_s*lam_s) + result
  90.         
  91.         
  92.  
  93.  
  94. # 定义容量比视频片段一样多一些的线程池
  95. pool = threadpool.ThreadPool(split_num+2)     
  96.  
  97. start_time = time.time() # 下面的多线程开始执行的时间
  98. start = 0 # 初始化，用于控制在哪一个shot里面
  99. for shot in range(len(shots)):
  100.     lst_vars = [shot,start]
  101.     func_var = [(lst_vars, None)]
  102.     start += len(shots[shot]) # start 增加位移，移动一个shot
  103.     requests = threadpool.makeRequests(calculate_lambda_s, func_var)
  104.     [pool.putRequest(req) for req in requests]
  105. pool.wait()
  106. print 'updating lambda_s %d second'% (time.time()-start_time)
  107.  
  108.  
  109.  
  110. # 定义容量为 total_topic 的一半
  111. pool_cal = threadpool.ThreadPool(total_topic/2)  
  112.  
  113. # x_u_c_t 的更新代码
  114. # 注意 ：这里的 comment_all 已经排过序了，和上面的不一样
  115. def calculate_x_u_c_t(i,start):
  116.     for topic in range(total_topic):
  117.         result = 0
  118.         for j in range(start,start+user_ct.iloc[i]):
  119.             lambda_s_t = comment_all_sort.iloc[j,topic+total_topic+total_topic+2]
  120.             m_pre_c_t = comment_all_sort.iloc[j,topic+total_topic+2]
  121.             x_u = x_u_c_t.iloc[j,topic+1]
  122.             print(lambda_s_t)
  123.             print(m_pre_c_t)
  124.             print(x_u)
  125.             t1 = lambda_s_t*dlgt(x_u*lambda_s_t + m_pre_c_t)
  126.             t2 = []
  127.             for t in range(total_topic):
  128.                 lst_vars = [comment_all_sort.iloc[j,t+2]*comment_all_sort.iloc[j,t+total_topic+total_topic+2]+comment_all_sort.iloc[j,t+total_topic+2],t2]
  129.                 func_var = [(lst_vars, None)]
  130.                 requests = threadpool.makeRequests(add_t2, func_var)
  131.                 [pool_cal.putRequest(req) for req in requests]
  132.             pool_cal.wait()
  133.             t2 = sum(t2)
  134.             print(t2)
  135.             t3 = eur.phi(t2+len(shots[int(comment_all_sort.ix[j,['shot']])][int(comment_all_sort.ix[j,['com']])]))
  136.             t2 = eur.phi(t2)
  137.             n_tc = 0
  138.             for word in shots[int(comment_all_sort.ix[j,['shot']])][int(comment_all_sort.ix[j,['com']])]:
  139.                 word = word.encode('utf-8')
  140.                 if word != ' ' :
  141.                     try:
  142.                         num = word2id[column][word]
  143.                         n_tc += pmodel.nw[num][topic]
  144.                     except Exception,e:  
  145.                         print Exception,":",e
  146.             t4 = eur.phi(lgt(x_u*lambda_s_t + m_pre_c_t)+ n_tc)
  147.             t5 = eur.phi(lgt(x_u*lambda_s_t + m_pre_c_t))
  148.             result += t1 * (t2 - t3 + t4 - t5)
  149.         x_u_c_t.iloc[j,topic+1] = x_u_c_t.iloc[j,topic+1] - yita*(-x_u/(comment_all_sort.iloc[j,topic+2]*comment_all_sort.iloc[j,topic+2]) + result)
  150.         print(x_u_c_t.iloc[j,topic+1])
  151.  
  152. # 定义容量比用户数量十分之一多一些的线程池
  153. pool = threadpool.ThreadPool(len(x_u_c_t)/10+2)     
  154.  
  155. user_ct = comment_all_sort.groupby('user').count()['topic0']
  156. yita_x_u_c_t = x_u_c_t.copy()
  157. yita = 0.3
  158. start_time = time.time() # 下面的多线程开始执行的时间
  159. start = 0 # 初始化，用于控制在哪一个shot里面
  160. for i in range(len(user_ct)):
  161.     lst_vars = [i,start]
  162.     func_var = [(lst_vars, None)]
  163.     start += user_ct.iloc[i] # start 增加位移，移动一个shot
  164.     requests = threadpool.makeRequests(calculate_x_u_c_t, func_var)
  165.     [pool.putRequest(req) for req in requests]
  166. pool.wait()
  167. print 'updating x_u_c_t %d second'% (time.time()-start_time)

到现在为止我们所需要的新功能就都实现啦，后面需要的就是遵循之前的伪代码图去阶段更新参数~

beta 版本先写到这，后面我还会补充的，代码整合过几天再做，服务器被老师关掉了 -_-||

paper done 2017/05/12
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/163450
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号