Topic Models using Julia

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

1. module TopicModels
   
2. 
   
3. import Base.length
   
4. 
   
5. typealias RaggedMatrix{T} Array{Array{T,1},1}
   
6. 
   
7. type Corpus
   
8.   documents::RaggedMatrix{Int64}
   
9.   weights::RaggedMatrix{Float64}
   
10. 
    
11.   Corpus(documents::RaggedMatrix{Int64},
    
12.          weights::RaggedMatrix{Float64}) = begin
    
13.     return new(
    
14.       documents,
    
15.       weights
    
16.     )
    
17.   end
    
18.   
    
19.   Corpus(documents::RaggedMatrix{Int64}) = begin
    
20.     weights = map(documents) do doc
    
21.       ones(Float64, length(doc))
    
22.     end
    
23.     return new(
    
24.       documents,
    
25.       weights
    
26.     )
    
27.   end
    
28. end
    
29. 
    
30. type Model
    
31.   alphaPrior::Vector{Float64}
    
32.   betaPrior::Float64
    
33.   topics::Array{Float64,2}
    
34.   topicSums::Vector{Float64}
    
35.   documentSums::Array{Float64,2}
    
36.   assignments::RaggedMatrix{Int64}
    
37.   frozen::Bool
    
38.   corpus::Corpus
    
39. 
    
40.   Model(alphaPrior::Vector{Float64},
    
41.         betaPrior::Float64,
    
42.         V::Int64,
    
43.         corpus::Corpus) = begin
    
44.     K = length(alphaPrior)
    
45.     m = new(
    
46.       alphaPrior,
    
47.       betaPrior,
    
48.       zeros(Float64, K, V), # topics
    
49.       zeros(Float64, K), # topicSums
    
50.       zeros(Float64, K, length(corpus.documents)), #documentSums
    
51.       fill(Array(Int64, 0), length(corpus.documents)), # assignments
    
52.       false,
    
53.       corpus
    
54.     )
    
55.     initializeAssignments(m)
    
56.     return m
    
57.   end
    
58. 
    
59.   Model(trainedModel::Model, corpus::Corpus) = begin
    
60.     m = new(
    
61.       trainedModel.alphaPrior,
    
62.       trainedModel.betaPrior,
    
63.       trainedModel.topics,
    
64.       trainedModel.topicSums,
    
65.       trainedModel.documentSums,
    
66.       fill(Array(Int64, 0), length(corpus.documents)),
    
67.       true,
    
68.       corpus
    
69.     )
    
70.     initializeAssignments(m)
    
71.     return m
    
72.   end
    
73. end
    
74. 
    
75. function length(corpus::Corpus)
    
76.   return length(corpus.documents)
    
77. end
    
78. 
    
79. function initializeAssignments(model::Model)
    
80.   for dd in 1:length(model.corpus)
    
81.     @inbounds words = model.corpus.documents[dd]
    
82.     @inbounds model.assignments[dd] = fill(0, length(words))
    
83.     for ww in 1:length(words)
    
84.       @inbounds word = words[ww]
    
85.       topic = sampleMultinomial(model.alphaPrior)
    
86.       @inbounds model.assignments[dd][ww] = topic
    
87.       updateSufficientStatistics(
    
88.         word, topic, dd, model.corpus.weights[dd][ww], model)
    
89.     end
    
90.   end
    
91.   return
    
92. end
    
93. 
    
94. function sampleMultinomial(p::Array{Float64,1})
    
95.   pSum = sum(p)
    
96.   r = rand() * pSum
    
97.   K = length(p)
    
98.   for k in 1:K
    
99.     if r < p[k]
    
100.       return k
     
101.     else
     
102.       r -= p[k]
     
103.     end
     
104.   end
     
105.   return 0
     
106. end
     
107. 
     
108. function wordDistribution(word::Int,
     
109.                           document::Int,
     
110.                           model::Model,
     
111.                           out::Vector{Float64})
     
112.   V = size(model.topics, 2)
     
113.   for ii in 1:length(out)
     
114.     u = (model.documentSums[ii, document] + model.alphaPrior[ii]) *
     
115.         (model.topics[ii, word] + model.betaPrior) /
     
116.         (model.topicSums[ii] + V * model.betaPrior)
     
117.     @inbounds out[ii] = u
     
118.   end
     
119.   return
     
120. end
     
121. 
     
122. function sampleWord(word::Int,
     
123.                     document::Int,
     
124.                     model::Model,
     
125.                     p::Vector{Float64})
     
126.   wordDistribution(word, document, model, p)
     
127.   sampleMultinomial(p)
     
128. end
     
129. 
     
130. 
     
131. function updateSufficientStatistics(word::Int64,
     
132.                                     topic::Int64,
     
133.                                     document::Int64,
     
134.                                     scale::Float64,
     
135.                                     model::Model)
     
136.   fr = float64(!model.frozen)
     
137.   @inbounds model.documentSums[topic, document] += scale
     
138.   @inbounds model.topicSums[topic] += scale * fr
     
139.   @inbounds model.topics[topic, word] += scale * fr
     
140.   return
     
141. end
     
142. 
     
143. function sampleDocument(document::Int,
     
144.                         model::Model)
     
145.   @inbounds words = model.corpus.documents[document]
     
146.   Nw = length(words)
     
147.   @inbounds weights = model.corpus.weights[document]
     
148.   K = length(model.alphaPrior)
     
149.   p = Array(Float64, K)
     
150.   @inbounds assignments = model.assignments[document]
     
151.   for ii in 1:Nw
     
152.     @inbounds word = words[ii]
     
153.     @inbounds oldTopic = assignments[ii]
     
154.     updateSufficientStatistics(word, oldTopic, document, -weights[ii], model)
     
155.     newTopic = sampleWord(word, document, model, p)
     
156.     @inbounds assignments[ii] = newTopic
     
157.     updateSufficientStatistics(word, newTopic, document, weights[ii], model)
     
158.   end
     
159.   return
     
160. end
     
161. 
     
162. function sampleCorpus(model::Model)
     
163.   for ii in 1:length(model.corpus)
     
164.     sampleDocument(ii, model)
     
165.   end
     
166.   return
     
167. end
     
168. 
     
169. # Note, files are zero indexed, but we are 1-indexed.
     
170. function termToWordSequence(term::String)
     
171.   parts = split(term, ":")
     
172.   fill(int64(parts[1]) + 1, int64(parts[2]))
     
173. end
     
174. 
     
175. # The functions below are designed for public consumption
     
176. function trainModel(model::Model,
     
177.                     numIterations::Int64)
     
178.   for ii in 1:numIterations
     
179.     println(string("Iteration ", ii, "..."))
     
180.     sampleCorpus(model)
     
181.   end
     
182.   return
     
183. end
     
184. 
     
185. function topTopicWords(model::Model,
     
186.                        lexicon::Array{ASCIIString,1},
     
187.                        numWords::Int64)
     
188.   [lexicon[reverse(sortperm(model.topics'[1:end, row]))[1:numWords]]
     
189.    for row in 1:size(model.topics,1)]
     
190. end
     
191. 
     
192. function readDocuments(stream)
     
193.   lines = readlines(stream)
     
194.   convert(
     
195.     RaggedMatrix{Int64},
     
196.     [apply(vcat, [termToWordSequence(term) for term in split(line, " ")[2:end]])
     
197.      for line in lines])
     
198. end
     
199. 
     
200. function readLexicon(stream)
     
201.   lines = readlines(stream)
     
202.   map(chomp, convert(Array{String,1}, lines))
     
203. end
     
204. 
     
205. export Corpus,
     
206.        Model,
     
207.        readDocuments,
     
208.        readLexicon,
     
209.        topTopicWords,
     
210.        trainModel
     
211. 
     
212. end

复制代码

In machine learning and natural language processing, a topic model is a type of statistical model for discovering the abstract "topics" that occur in a collection of documents. Intuitively, given that a document is about a particular topic, one would expect particular words to appear in the document more or less frequently: "dog" and "bone" will appear more often in documents about dogs, "cat" and "meow" will appear in documents about cats, and "the" and "is" will appear equally in both. A document typically concerns multiple topics in different proportions; thus, in a document that is 10% about cats and 90% about dogs, there would probably be about 9 times more dog words than cat words. A topic model captures this intuition in a mathematical framework, which allows examining a set of documents and discovering, based on the statistics of the words in each, what the topics might be and what each document's balance of topics is.

In practice researchers attempt to fit appropriate model parameters to the data corpus using one of several heuristics for maximum likelihood fit. A recent survey by Blei describes this suite of algorithms.[4] Several groups of researchers starting with Papadimitriou et al.[1] have attempted to design algorithms with probable guarantees. Assuming that the data was actually generated by the model in question, they try to design algorithms that probably find the model that was used to create the data. Techniques used here includesingular value decomposition (SVD), the method of moments, and very recently an algorithm based upon non-negative matrix factorization (NMF). This last algorithm also generalizes to topic models that allow correlations among topics

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏1 回帖

关键词：models topic Using model Julia

不错不错

谢谢分享