tomoto 0.1.3 → 0.1.4

data/vendor/tomotopy/src/TopicModel/HPAModel.hpp

@@ -28,7 +28,8 @@ namespace tomoto
 		typename _Interface = IHPAModel,
 		typename _Derived = void,
 		typename _DocType = DocumentHPA<_tw>,
-		typename _ModelState = ModelStateHPA<_tw>>
+		typename _ModelState = ModelStateHPA<_tw>
+	>
 	class HPAModel : public LDAModel<_tw, _RandGen, 0, _Interface,
 		typename std::conditional<std::is_same<_Derived, void>::value, HPAModel<_tw, _RandGen, _Exclusive>, _Derived>::type,
 		_DocType, _ModelState>
@@ -250,8 +251,6 @@ namespace tomoto
 		template<ParallelScheme _ps, typename _ExtraDocData>
 		void mergeState(ThreadPool& pool, _ModelState& globalState, _ModelState& tState, _ModelState* localData, _RandGen*, const _ExtraDocData& edd) const
 		{
-			std::vector<std::future<void>> res;
-
 			tState = globalState;
 			globalState = localData[0];
 			for (size_t i = 1; i < pool.getNumWorkers(); ++i)
@@ -276,15 +275,6 @@ namespace tomoto
 				globalState.numByTopicWord[1] = globalState.numByTopicWord[1].cwiseMax(0);
 				globalState.numByTopicWord[2] = globalState.numByTopicWord[2].cwiseMax(0);
 			}
-
-			for (size_t i = 0; i < pool.getNumWorkers(); ++i)
-			{
-				res.emplace_back(pool.enqueue([&, this, i](size_t threadId)
-				{
-					localData[i] = globalState;
-				}));
-			}
-			for (auto& r : res) r.get();
 		}
 
 		std::vector<uint64_t> _getTopicsCount() const
@@ -379,7 +369,7 @@ namespace tomoto
 
 		void prepareDoc(_DocType& doc, size_t docId, size_t wordSize) const
 		{
-			doc.numByTopic.init(nullptr, this->K + 1);
+			doc.numByTopic.init(nullptr, this->K + 1, 1);
 			doc.numByTopic1_2 = Eigen::Matrix<WeightType, -1, -1>::Zero(this->K, K2 + 1);
 			doc.Zs = tvector<Tid>(wordSize);
 			doc.Z2s = tvector<Tid>(wordSize);
@@ -575,7 +565,7 @@ namespace tomoto
 	template<typename _TopicModel>
 	void DocumentHPA<_tw>::update(WeightType * ptr, const _TopicModel & mdl)
 	{
-		this->numByTopic.init(ptr, mdl.getK() + 1);
+		this->numByTopic.init(ptr, mdl.getK() + 1, 1);
 		this->numByTopic1_2 = Eigen::Matrix<WeightType, -1, -1>::Zero(mdl.getK(), mdl.getK2() + 1);
 		for (size_t i = 0; i < this->Zs.size(); ++i)
 		{

data/vendor/tomotopy/src/TopicModel/LDA.h

@@ -5,32 +5,67 @@ namespace tomoto
 {
     enum class TermWeight { one, idf, pmi, size };
 
-	template<typename _Scalar>
-	struct ShareableVector : Eigen::Map<Eigen::Matrix<_Scalar, -1, 1>>
+	template<typename _Scalar, Eigen::Index _rows, Eigen::Index _cols>
+	struct ShareableMatrix : Eigen::Map<Eigen::Matrix<_Scalar, _rows, _cols>>
 	{
-		Eigen::Matrix<_Scalar, -1, 1> ownData;
-		ShareableVector(_Scalar* ptr = nullptr, Eigen::Index len = 0) 
-			: Eigen::Map<Eigen::Matrix<_Scalar, -1, 1>>(nullptr, 0)
+		using BaseType = Eigen::Map<Eigen::Matrix<_Scalar, _rows, _cols>>;
+		Eigen::Matrix<_Scalar, _rows, _cols> ownData;
+
+		ShareableMatrix(_Scalar* ptr = nullptr, Eigen::Index rows = 0, Eigen::Index cols = 0) 
+			: BaseType(nullptr, _rows != -1 ? _rows : 0, _cols != -1 ? _cols : 0)
 		{
-			init(ptr, len);
+			init(ptr, rows, cols);
 		}
 
-		void init(_Scalar* ptr, Eigen::Index len)
+		ShareableMatrix(const ShareableMatrix& o)
+			: BaseType(nullptr, _rows != -1 ? _rows : 0, _cols != -1 ? _cols : 0), ownData{ o.ownData }
 		{
-			if (!ptr && len)
+			if (o.ownData.data())
+			{
+				new (this) BaseType(ownData.data(), ownData.rows(), ownData.cols());
+			}
+			else
 			{
-				ownData = Eigen::Matrix<_Scalar, -1, 1>::Zero(len);
+				new (this) BaseType((_Scalar*)o.data(), o.rows(), o.cols());
+			}
+		}
+
+		ShareableMatrix(ShareableMatrix&& o) = default;
+
+		ShareableMatrix& operator=(const ShareableMatrix& o)
+		{
+			if (o.ownData.data())
+			{
+				ownData = o.ownData;
+				new (this) BaseType(ownData.data(), ownData.rows(), ownData.cols());
+			}
+			else
+			{
+				new (this) BaseType((_Scalar*)o.data(), o.rows(), o.cols());
+			}
+			return *this;
+		}
+
+		ShareableMatrix& operator=(ShareableMatrix&& o) = default;
+
+		void init(_Scalar* ptr, Eigen::Index rows, Eigen::Index cols)
+		{
+			if (!ptr && rows && cols)
+			{
+				ownData = Eigen::Matrix<_Scalar, _rows, _cols>::Zero(_rows != -1 ? _rows : rows, _cols != -1 ? _cols : cols);
 				ptr = ownData.data();
 			}
-			// is this the best way??
-			this->m_data = ptr;
-			((Eigen::internal::variable_if_dynamic<Eigen::Index, -1>*)&this->m_rows)->setValue(len);
+			else
+			{
+				ownData = Eigen::Matrix<_Scalar, _rows, _cols>{};
+			}
+			new (this) BaseType(ptr, _rows != -1 ? _rows : rows, _cols != -1 ? _cols : cols);
 		}
 
-		void conservativeResize(size_t newSize)
+		void conservativeResize(size_t newRows, size_t newCols)
 		{
-			ownData.conservativeResize(newSize);
-			init(ownData.data(), ownData.size());
+			ownData.conservativeResize(_rows != -1 ? _rows : newRows, _cols != -1 ? _cols : newCols);
+			new (this) BaseType(ownData.data(), ownData.rows(), ownData.cols());
 		}
 
 		void becomeOwner()
@@ -38,9 +73,26 @@ namespace tomoto
 			if (ownData.data() != this->m_data)
 			{
 				ownData = *this;
-				init(ownData.data(), ownData.size());
+				new (this) BaseType(ownData.data(), ownData.rows(), ownData.cols());
 			}
 		}
+
+		void serializerRead(std::istream& istr)
+		{
+			uint32_t rows = serializer::readFromStream<uint32_t>(istr);
+			uint32_t cols = serializer::readFromStream<uint32_t>(istr);
+			init(nullptr, rows, cols);
+			if (!istr.read((char*)this->data(), sizeof(_Scalar) * this->size()))
+				throw std::ios_base::failure(std::string("reading type '") + typeid(_Scalar).name() + std::string("' is failed"));
+		}
+
+		void serializerWrite(std::ostream& ostr) const
+		{
+			serializer::writeToStream<uint32_t>(ostr, (uint32_t)this->rows());
+			serializer::writeToStream<uint32_t>(ostr, (uint32_t)this->cols());
+			if (!ostr.write((const char*)this->data(), sizeof(_Scalar) * this->size()))
+				throw std::ios_base::failure(std::string("writing type '") + typeid(_Scalar).name() + std::string("' is failed"));
+		}
 	};
 
 	template<typename _Base, TermWeight _tw>
@@ -85,7 +137,7 @@ namespace tomoto
 
 		tvector<Tid> Zs;
 		tvector<Float> wordWeights;
-		ShareableVector<WeightType> numByTopic;
+		ShareableMatrix<WeightType, -1, 1> numByTopic;
 
 		DEFINE_SERIALIZER_AFTER_BASE_WITH_VERSION(DocumentBase, 0, Zs, wordWeights);
 		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(DocumentBase, 1, 0x00010001, Zs, wordWeights);

data/vendor/tomotopy/src/TopicModel/LDACVB0Model.hpp

@@ -163,7 +163,7 @@ namespace tomoto
 			{
 				res.emplace_back(pool.enqueue([&, this, ch, chStride](size_t threadId)
 				{
-					forRandom((this->docs.size() - 1 - ch) / chStride + 1, rgs[threadId](), [&, this](size_t id)
+					forShuffled((this->docs.size() - 1 - ch) / chStride + 1, rgs[threadId](), [&, this](size_t id)
 					{
 						static_cast<DerivedClass*>(this)->template sampleDocument<ParallelScheme::copy_merge>(
 							this->docs[id * chStride + ch], 0, id * chStride + ch,

data/vendor/tomotopy/src/TopicModel/LDAModel.hpp

@@ -58,7 +58,8 @@ namespace tomoto
 
 		Eigen::Matrix<Float, -1, 1> zLikelihood;
 		Eigen::Matrix<WeightType, -1, 1> numByTopic; // Dim: (Topic, 1)
-		Eigen::Matrix<WeightType, -1, -1> numByTopicWord; // Dim: (Topic, Vocabs)
+		//Eigen::Matrix<WeightType, -1, -1> numByTopicWord; // Dim: (Topic, Vocabs)
+		ShareableMatrix<WeightType, -1, -1> numByTopicWord; // Dim: (Topic, Vocabs)
 		DEFINE_SERIALIZER(numByTopic, numByTopicWord);
 	};
 
@@ -137,7 +138,8 @@ namespace tomoto
 		typename _Interface,
 		typename _Derived,
 		typename _DocType,
-		typename _ModelState>
+		typename _ModelState
+	>
 	class HDPModel;
 
 	template<TermWeight _tw, typename _RandGen,
@@ -145,7 +147,8 @@ namespace tomoto
 		typename _Interface = ILDAModel,
 		typename _Derived = void, 
 		typename _DocType = DocumentLDA<_tw>,
-		typename _ModelState = ModelStateLDA<_tw>>
+		typename _ModelState = ModelStateLDA<_tw>
+	>
 	class LDAModel : public TopicModel<_RandGen, _Flags, _Interface,
 		typename std::conditional<std::is_same<_Derived, void>::value, LDAModel<_tw, _RandGen, _Flags>, _Derived>::type,
 		_DocType, _ModelState>,
@@ -306,25 +309,23 @@ namespace tomoto
 				e = edd.chunkOffsetByDoc(partitionId + 1, docId);
 			}
 
-			size_t vOffset = (_ps == ParallelScheme::partition && partitionId) ? edd.vChunkOffset[partitionId - 1] : 0;
-
 			for (size_t w = b; w < e; ++w)
 			{
 				if (doc.words[w] >= this->realV) continue;
-				addWordTo<-1>(ld, doc, w, doc.words[w] - vOffset, doc.Zs[w]);
+				static_cast<const DerivedClass*>(this)->template addWordTo<-1>(ld, doc, w, doc.words[w], doc.Zs[w]);
 				Float* dist;
 				if (etaByTopicWord.size())
 				{
 					dist = static_cast<const DerivedClass*>(this)->template
-						getZLikelihoods<true>(ld, doc, docId, doc.words[w] - vOffset);
+						getZLikelihoods<true>(ld, doc, docId, doc.words[w]);
 				}
 				else
 				{
 					dist = static_cast<const DerivedClass*>(this)->template
-						getZLikelihoods<false>(ld, doc, docId, doc.words[w] - vOffset);
+						getZLikelihoods<false>(ld, doc, docId, doc.words[w]);
 				}
 				doc.Zs[w] = sample::sampleFromDiscreteAcc(dist, dist + K, rgs);
-				addWordTo<1>(ld, doc, w, doc.words[w] - vOffset, doc.Zs[w]);
+				static_cast<const DerivedClass*>(this)->template addWordTo<1>(ld, doc, w, doc.words[w], doc.Zs[w]);
 			}
 		}
 
@@ -335,7 +336,7 @@ namespace tomoto
 			// single-threaded sampling
 			if (_ps == ParallelScheme::none)
 			{
-				forRandom((size_t)std::distance(docFirst, docLast), rgs[0](), [&](size_t id)
+				forShuffled((size_t)std::distance(docFirst, docLast), rgs[0](), [&](size_t id)
 				{
 					static_cast<const DerivedClass*>(this)->presampleDocument(docFirst[id], id, *localData, *rgs, this->globalStep);
 					static_cast<const DerivedClass*>(this)->template sampleDocument<_ps, _infer>(
@@ -344,7 +345,7 @@ namespace tomoto
 
 				});
 			}
-			// multi-threaded sampling on partition ad update into global
+			// multi-threaded sampling on partition and update into global
 			else if (_ps == ParallelScheme::partition)
 			{
 				const size_t chStride = pool.getNumWorkers();
@@ -353,7 +354,7 @@ namespace tomoto
 					res = pool.enqueueToAll([&, i, chStride](size_t partitionId)
 					{
 						size_t didx = (i + partitionId) % chStride;
-						forRandom(((size_t)std::distance(docFirst, docLast) + (chStride - 1) - didx) / chStride, rgs[partitionId](), [&](size_t id)
+						forShuffled(((size_t)std::distance(docFirst, docLast) + (chStride - 1) - didx) / chStride, rgs[partitionId](), [&](size_t id)
 						{
 							if (i == 0)
 							{
@@ -380,7 +381,7 @@ namespace tomoto
 				{
 					res.emplace_back(pool.enqueue([&, ch, chStride](size_t threadId)
 					{
-						forRandom(((size_t)std::distance(docFirst, docLast) + (chStride - 1) - ch) / chStride, rgs[threadId](), [&](size_t id)
+						forShuffled(((size_t)std::distance(docFirst, docLast) + (chStride - 1) - ch) / chStride, rgs[threadId](), [&](size_t id)
 						{
 							static_cast<const DerivedClass*>(this)->presampleDocument(
 								docFirst[id * chStride + ch], id * chStride + ch, 
@@ -396,6 +397,16 @@ namespace tomoto
 				for (auto& r : res) r.get();
 				res.clear();
 			}
+			else
+			{
+				throw std::runtime_error{ "Unsupported ParallelScheme" };
+			}
+		}
+
+		template<ParallelScheme _ps, bool _infer, typename _DocIter>
+		void performSamplingGlobal(ThreadPool* pool, _ModelState& globalState, _RandGen* rgs, 
+			_DocIter docFirst, _DocIter docLast) const
+		{
 		}
 
 		template<typename _DocIter, typename _ExtraDocData>
@@ -444,7 +455,8 @@ namespace tomoto
 				size_t b = partitionId ? edd.vChunkOffset[partitionId - 1] : 0,
 					e = edd.vChunkOffset[partitionId];
 
-				localData[partitionId].numByTopicWord = globalState.numByTopicWord.block(0, b, globalState.numByTopicWord.rows(), e - b);
+				//localData[partitionId].numByTopicWord.matrix() = globalState.numByTopicWord.block(0, b, globalState.numByTopicWord.rows(), e - b);
+				localData[partitionId].numByTopicWord.init((WeightType*)globalState.numByTopicWord.data(), globalState.numByTopicWord.rows(), globalState.numByTopicWord.cols());
 				localData[partitionId].numByTopic = globalState.numByTopic;
 				if (!localData[partitionId].zLikelihood.size()) localData[partitionId].zLikelihood = globalState.zLikelihood;
 			});
@@ -467,16 +479,29 @@ namespace tomoto
 		}
 
 		template<ParallelScheme _ps>
-		void trainOne(ThreadPool& pool, _ModelState* localData, _RandGen* rgs)
+		void trainOne(ThreadPool& pool, _ModelState* localData, _RandGen* rgs, bool freeze_topics = false)
 		{
 			std::vector<std::future<void>> res;
 			try
 			{
-				performSampling<_ps, false>(pool, localData, rgs, res, 
-					this->docs.begin(), this->docs.end(), eddTrain);
+				static_cast<DerivedClass*>(this)->template performSampling<_ps, false>(pool, localData, rgs, res,
+					this->docs.begin(), this->docs.end(), eddTrain
+				);
 				static_cast<DerivedClass*>(this)->updateGlobalInfo(pool, localData);
 				static_cast<DerivedClass*>(this)->template mergeState<_ps>(pool, this->globalState, this->tState, localData, rgs, eddTrain);
-				static_cast<DerivedClass*>(this)->template sampleGlobalLevel<>(&pool, localData, rgs, this->docs.begin(), this->docs.end());
+				static_cast<DerivedClass*>(this)->template performSamplingGlobal<_ps, false>(&pool, this->globalState, rgs, 
+					this->docs.begin(), this->docs.end()
+				);
+				
+				if(freeze_topics) static_cast<DerivedClass*>(this)->template sampleGlobalLevel<GlobalSampler::freeze_topics>(
+					&pool, &this->globalState, rgs, this->docs.begin(), this->docs.end()
+				);
+				else static_cast<DerivedClass*>(this)->template sampleGlobalLevel<GlobalSampler::train>(
+					&pool, &this->globalState, rgs, this->docs.begin(), this->docs.end()
+				);
+
+				static_cast<DerivedClass*>(this)->template distributeMergedState<_ps>(pool, this->globalState, localData);
+				
 				if (this->globalStep >= this->burnIn && optimInterval && (this->globalStep + 1) % optimInterval == 0)
 				{
 					static_cast<DerivedClass*>(this)->optimizeParameters(pool, localData, rgs);
@@ -503,8 +528,6 @@ namespace tomoto
 		template<ParallelScheme _ps, typename _ExtraDocData>
 		void mergeState(ThreadPool& pool, _ModelState& globalState, _ModelState& tState, _ModelState* localData, _RandGen*, const _ExtraDocData& edd) const
 		{
-			std::vector<std::future<void>> res;
-
 			if (_ps == ParallelScheme::copy_merge)
 			{
 				tState = globalState;
@@ -517,10 +540,27 @@ namespace tomoto
 				// make all count being positive
 				if (_tw != TermWeight::one)
 				{
-					globalState.numByTopicWord = globalState.numByTopicWord.cwiseMax(0);
+					globalState.numByTopicWord.matrix() = globalState.numByTopicWord.cwiseMax(0);
+				}
+				globalState.numByTopic = globalState.numByTopicWord.rowwise().sum();
+			}
+			else if (_ps == ParallelScheme::partition)
+			{
+				// make all count being positive
+				if (_tw != TermWeight::one)
+				{
+					globalState.numByTopicWord.matrix() = globalState.numByTopicWord.cwiseMax(0);
 				}
 				globalState.numByTopic = globalState.numByTopicWord.rowwise().sum();
+			}
+		}
 
+		template<ParallelScheme _ps>
+		void distributeMergedState(ThreadPool& pool, _ModelState& globalState, _ModelState* localData) const
+		{
+			std::vector<std::future<void>> res;
+			if (_ps == ParallelScheme::copy_merge)
+			{
 				for (size_t i = 0; i < pool.getNumWorkers(); ++i)
 				{
 					res.emplace_back(pool.enqueue([&, i](size_t)
@@ -531,22 +571,6 @@ namespace tomoto
 			}
 			else if (_ps == ParallelScheme::partition)
 			{
-				res = pool.enqueueToAll([&](size_t partitionId)
-				{
-					size_t b = partitionId ? edd.vChunkOffset[partitionId - 1] : 0,
-						e = edd.vChunkOffset[partitionId];
-					globalState.numByTopicWord.block(0, b, globalState.numByTopicWord.rows(), e - b) = localData[partitionId].numByTopicWord;
-				});
-				for (auto& r : res) r.get();
-				res.clear();
-
-				// make all count being positive
-				if (_tw != TermWeight::one)
-				{
-					globalState.numByTopicWord = globalState.numByTopicWord.cwiseMax(0);
-				}
-				globalState.numByTopic = globalState.numByTopicWord.rowwise().sum();
-
 				res = pool.enqueueToAll([&](size_t threadId)
 				{
 					localData[threadId].numByTopic = globalState.numByTopic;
@@ -560,16 +584,11 @@ namespace tomoto
 		ex) document pathing at hLDA model
 		* if pool is nullptr, workers has been already pooled and cannot branch works more.
 		*/
-		template<typename _DocIter>
+		template<GlobalSampler _gs, typename _DocIter>
 		void sampleGlobalLevel(ThreadPool* pool, _ModelState* localData, _RandGen* rgs, _DocIter first, _DocIter last) const
 		{
 		}
 
-		template<typename _DocIter>
-		void sampleGlobalLevel(ThreadPool* pool, _ModelState* localData, _RandGen* rgs, _DocIter first, _DocIter last)
-		{
-		}
-
 		template<typename _DocIter>
 		double getLLDocs(_DocIter _first, _DocIter _last) const
 		{
@@ -592,16 +611,33 @@ namespace tomoto
 			double ll = 0;
 			const size_t V = this->realV;
 			// topic-word distribution
-			auto lgammaEta = math::lgammaT(eta);
-			ll += math::lgammaT(V*eta) * K;
-			for (Tid k = 0; k < K; ++k)
+			if (etaByTopicWord.size())
 			{
-				ll -= math::lgammaT(ld.numByTopic[k] + V * eta);
-				for (Vid v = 0; v < V; ++v)
+				for (Tid k = 0; k < K; ++k)
 				{
-					if (!ld.numByTopicWord(k, v)) continue;
-					ll += math::lgammaT(ld.numByTopicWord(k, v) + eta) - lgammaEta;
-					assert(std::isfinite(ll));
+					Float etasum = etaByTopicWord.row(k).sum();
+					ll += math::lgammaT(etasum) - math::lgammaT(ld.numByTopic[k] + etasum);
+					for (Vid v = 0; v < V; ++v)
+					{
+						if (!ld.numByTopicWord(k, v)) continue;
+						ll += math::lgammaT(ld.numByTopicWord(k, v) + etaByTopicWord(v, k)) - math::lgammaT(etaByTopicWord(v, k));
+						assert(std::isfinite(ll));
+					}
+				}
+			}
+			else
+			{
+				auto lgammaEta = math::lgammaT(eta);
+				ll += math::lgammaT(V * eta) * K;
+				for (Tid k = 0; k < K; ++k)
+				{
+					ll -= math::lgammaT(ld.numByTopic[k] + V * eta);
+					for (Vid v = 0; v < V; ++v)
+					{
+						if (!ld.numByTopicWord(k, v)) continue;
+						ll += math::lgammaT(ld.numByTopicWord(k, v) + eta) - lgammaEta;
+						assert(std::isfinite(ll));
+					}
 				}
 			}
 			return ll;
@@ -637,9 +673,9 @@ namespace tomoto
 		void prepareDoc(_DocType& doc, size_t docId, size_t wordSize) const
 		{
 			sortAndWriteOrder(doc.words, doc.wOrder);
-			doc.numByTopic.init(getTopicDocPtr(docId), K);
+			doc.numByTopic.init(getTopicDocPtr(docId), K, 1);
 			doc.Zs = tvector<Tid>(wordSize);
-			if(_tw != TermWeight::one) doc.wordWeights.resize(wordSize, 1);
+			if(_tw != TermWeight::one) doc.wordWeights.resize(wordSize);
 		}
 
 		void prepareWordPriors()
@@ -664,7 +700,8 @@ namespace tomoto
 			if (initDocs)
 			{
 				this->globalState.numByTopic = Eigen::Matrix<WeightType, -1, 1>::Zero(K);
-				this->globalState.numByTopicWord = Eigen::Matrix<WeightType, -1, -1>::Zero(K, V);
+				//this->globalState.numByTopicWord = Eigen::Matrix<WeightType, -1, -1>::Zero(K, V);
+				this->globalState.numByTopicWord.init(nullptr, K, V);
 			}
 			if(m_flags & flags::continuous_doc_data) numByTopicDoc = Eigen::Matrix<WeightType, -1, -1>::Zero(K, this->docs.size());
 		}
@@ -791,12 +828,18 @@ namespace tomoto
 				for (size_t i = 0; i < maxIter; ++i)
 				{
 					std::vector<std::future<void>> res;
-					performSampling<_ps, true>(pool,
+					static_cast<const DerivedClass*>(this)->template performSampling<_ps, true>(pool,
 						(m_flags & flags::shared_state) ? &tmpState : localData.data(), rgs.data(), res,
-						docFirst, docLast, edd);
+						docFirst, docLast, edd
+					);
 					static_cast<const DerivedClass*>(this)->template mergeState<_ps>(pool, tmpState, tState, localData.data(), rgs.data(), edd);
-					static_cast<const DerivedClass*>(this)->template sampleGlobalLevel<>(
-						&pool, (m_flags & flags::shared_state) ? &tmpState : localData.data(), rgs.data(), docFirst, docLast);
+					static_cast<const DerivedClass*>(this)->template performSamplingGlobal<_ps, true>(&pool, tmpState, rgs.data(),
+						docFirst, docLast
+					);
+					static_cast<const DerivedClass*>(this)->template sampleGlobalLevel<GlobalSampler::inference>(
+						&pool, (m_flags & flags::shared_state) ? &tmpState : localData.data(), rgs.data(), docFirst, docLast
+					);
+					static_cast<const DerivedClass*>(this)->template distributeMergedState<_ps>(pool, tmpState, localData.data());
 				}
 				double ll = static_cast<const DerivedClass*>(this)->getLLRest(tmpState) - static_cast<const DerivedClass*>(this)->getLLRest(this->globalState);
 				ll += static_cast<const DerivedClass*>(this)->template getLLDocs<>(docFirst, docLast);
@@ -817,7 +860,9 @@ namespace tomoto
 					{
 						static_cast<const DerivedClass*>(this)->presampleDocument(*d, -1, tmpState, rgc, i);
 						static_cast<const DerivedClass*>(this)->template sampleDocument<ParallelScheme::none, true>(*d, edd, -1, tmpState, rgc, i);
-						static_cast<const DerivedClass*>(this)->template sampleGlobalLevel<>(
+						static_cast<const DerivedClass*>(this)->template performSamplingGlobal<_ps, true>(&pool, tmpState, &rgc,
+							&*d, &*d + 1);
+						static_cast<const DerivedClass*>(this)->template sampleGlobalLevel<GlobalSampler::inference>(
 							&pool, &tmpState, &rgc, &*d, &*d + 1);
 					}
 					double ll = static_cast<const DerivedClass*>(this)->getLLRest(tmpState) - gllRest;
@@ -845,7 +890,9 @@ namespace tomoto
 							static_cast<const DerivedClass*>(this)->template sampleDocument<ParallelScheme::none, true>(
 								*d, edd, -1, tmpState, rgc, i
 							);
-							static_cast<const DerivedClass*>(this)->template sampleGlobalLevel<>(
+							static_cast<const DerivedClass*>(this)->template performSamplingGlobal<_ps, true>(nullptr, tmpState, &rgc,
+								&*d, &*d + 1);
+							static_cast<const DerivedClass*>(this)->template sampleGlobalLevel<GlobalSampler::inference>(
 								nullptr, &tmpState, &rgc, &*d, &*d + 1
 							);
 						}
@@ -1036,7 +1083,7 @@ namespace tomoto
 	template<typename _TopicModel>
 	void DocumentLDA<_tw>::update(WeightType* ptr, const _TopicModel& mdl)
 	{
-		numByTopic.init(ptr, mdl.getK());
+		numByTopic.init(ptr, mdl.getK(), 1);
 		for (size_t i = 0; i < Zs.size(); ++i)
 		{
 			if (this->words[i] >= mdl.getV()) continue;