def fit(self, documents): ''' Implement a parallel version of CGS over documents This requires storing a copy of sum_K and topics to avoid conflicts There's a synchronization period over which to reconcile the global sum_K/topics with the thread's local Additional feature is setting split_words = True This splits V into num_threads regions and provides locking mechanisms to update topics. This avoids the need to store the local topics and synchronize in case the corpus is very large, however the extra locking may hinder speedups ''' # topic -> words distribution topics = np.zeros((self.num_topics, documents.shape[1]), dtype=np.float) # documents -> topic distribution gamma = np.zeros((documents.shape[0], self.num_topics), dtype=np.float) # sum of types per topic sum_K = np.zeros((self.num_topics), dtype=np.dtype("i")) # sampling distributions sampling = np.zeros( (documents.shape[0], documents.shape[1], np.max(documents)), dtype=np.dtype("i")) self._pCGS(documents, topics, gamma, sum_K, sampling) assert np.sum(sum_K) == np.sum(documents), "Sum_K not synced: {}, {}".format( np.sum(sum_K), np.sum(documents)) assert np.sum(topics) == np.sum(documents), "topics not synced: {}, {}".format( np.sum(topics), np.sum(documents)) self.topics = topics self.gamma = gamma self.sum_K = sum_K # Compute the perplexity of the trained model on the train data self.perplexity_train = Evaluation._log_likelihood(self, gamma, documents)
def fit(self, dtm): ''' Parallel version of the lda: the temporary topics are computed in parallel for each document inside a mini-batch ''' # Initialisation num_docs, num_words = dtm.shape topics = np.random.gamma(100., 1./100., (self.num_topics, num_words)) gamma = np.ones((num_docs, self.num_topics)) ExpELogBeta = np.zeros((self.num_topics, num_words)) topics_int = np.zeros((self.num_threads, self.num_topics, num_words)) num_batch = num_docs / self.batch_size batches = np.array_split( np.arange(num_docs, dtype=np.int32), num_batch) for it_batch in range(num_batch): ovi_cython.exp_digamma2d(topics, ExpELogBeta) docs_thread = np.array_split(batches[it_batch], self.num_threads) # vector of threads threads = [None]*self.num_threads for tid in range(self.num_threads): threads[tid] = threading.Thread(target=self._worker_estep, args=(docs_thread[tid], dtm, topics_int[tid, :, :], gamma, ExpELogBeta)) threads[tid].start() for thread in threads: thread.join() # Synchronizing the topics_int topics_int_tot = np.sum(topics_int, axis=0) # Initialize the list of topics int for the next batch topics_int[:, :, :] = 0 # M-step indices = (np.sum(dtm[batches[it_batch], :], axis=0) > 0).astype( np.int32) ovi_cython.m_step(topics, topics_int_tot, indices, num_docs, self.batch_size, self.tau, self.kappa, it_batch) self.topics = topics self.gamma = gamma # Compute the perplexity of the trained model on the train data self.perplexity_train = Evaluation._log_likelihood(self, gamma, dtm)
# Initialising parameters # Batchsize num_topics = 20 num_threads = 8 # Constructing the model # UNCOMMENT THE NEXT LINE TO USE OVI: lda = oviLDA(num_topics, num_threads) # UNCOMMENT THE NEXT LINE TO USE CGS: # lda = cgsLDA(num_topics, num_threads) print '' print 'Fitting an LDA model on the Reuters dataset with 20 topics:' # Fitting the model np.random.seed(0) start = time.time() lda.fit(dtm) end = time.time()-start print 'Run time: %s sec with 8 threads' %(end) #Evaluation.print_topic(lda,vocablv, num_top_words=10) print '' print Evaluation.perplexity(lda,dtm) print '' print 'Perplexity on train dataset is %s' % lda.perplexity_train