tomoto 0.1.4 → 0.2.0

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

@@ -56,12 +56,21 @@ namespace tomoto
 		template<typename _TopicModel> void update(WeightType* ptr, const _TopicModel& mdl);
 	};
 
+	struct HDPArgs : public LDAArgs
+	{
+		Float gamma = 0.1;
+		
+		HDPArgs()
+		{
+			k = 2;
+		}
+	};
+
     class IHDPModel : public ILDAModel
 	{
 	public:
 		using DefaultDocType = DocumentHDP<TermWeight::one>;
-		static IHDPModel* create(TermWeight _weight, size_t _K = 1, 
-			Float alpha = 0.1, Float eta = 0.01, Float gamma = 0.1, size_t seed = std::random_device{}(),
+		static IHDPModel* create(TermWeight _weight, const HDPArgs& args,
 			bool scalarRng = false);
 
 		virtual Float getGamma() const = 0;

data/vendor/tomotopy/src/TopicModel/HDPModel.cpp

@@ -2,12 +2,8 @@
 
 namespace tomoto
 {
-	/*template class HDPModel<TermWeight::one>;
-	template class HDPModel<TermWeight::idf>;
-	template class HDPModel<TermWeight::pmi>;*/
-
-    IHDPModel* IHDPModel::create(TermWeight _weight, size_t _K, Float _alpha , Float _eta, Float _gamma, size_t seed, bool scalarRng)
+    IHDPModel* IHDPModel::create(TermWeight _weight, const HDPArgs& args, bool scalarRng)
 	{
-		TMT_SWITCH_TW(_weight, scalarRng, HDPModel, _K, _alpha, _eta, _gamma, seed);
+		TMT_SWITCH_TW(_weight, scalarRng, HDPModel, args);
 	}
 }

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

@@ -14,7 +14,7 @@ namespace tomoto
 	template<TermWeight _tw>
 	struct ModelStateHDP : public ModelStateLDA<_tw>
 	{
-		Eigen::Matrix<Float, -1, 1> tableLikelihood, topicLikelihood;
+		Vector tableLikelihood, topicLikelihood;
 		Eigen::Matrix<int32_t, -1, 1> numTableByTopic;
 		size_t totalTable = 0;
 
@@ -397,58 +397,47 @@ namespace tomoto
 
 		void prepareDoc(_DocType& doc, size_t docId, size_t wordSize) const
 		{
+			sortAndWriteOrder(doc.words, doc.wOrder);
 			doc.numByTopic.init(nullptr, this->K, 1);
 			doc.numTopicByTable.clear();
-			doc.Zs = tvector<Tid>(wordSize);
+			doc.Zs = tvector<Tid>(wordSize, non_topic_id);
 			if (_tw != TermWeight::one) doc.wordWeights.resize(wordSize);
 		}
 
-		template<bool _Infer>
+		template<bool _infer>
 		void updateStateWithDoc(typename BaseClass::Generator& g, _ModelState& ld, _RandGen& rgs, _DocType& doc, size_t i) const
 		{
-			// generate tables for each topic when inferring
-			if (_Infer)
+			Tid t;
+			std::vector<double> dist;
+			dist.emplace_back(this->alpha);
+			for (auto& d : doc.numTopicByTable) dist.emplace_back(d.num);
+			std::discrete_distribution<Tid> ddist{ dist.begin(), dist.end() };
+			t = ddist(rgs);
+			if (t == 0)
 			{
-				if (i < this->K)
+				// new table
+				Tid k;
+				if (_infer)
 				{
-					Tid t = i;
-					if (isLiveTopic(i))
+					std::uniform_int_distribution<> theta{ 0, this->K - 1 };
+					do
 					{
-						t = doc.addNewTable(i);
-					}
-					else
-					{
-						t = std::uniform_int_distribution<size_t>{ 0, doc.getNumTable() - 1 }(rgs);
-					}
-					++ld.numTableByTopic[doc.numTopicByTable[t].topic];
-					++ld.totalTable;
-					doc.Zs[i] = t;
-				}
-				else doc.Zs[i] = std::uniform_int_distribution<size_t>{ 0, doc.getNumTable() - 1 }(rgs);
-			}
-			// generate tables following CRP
-			else
-			{
-				Tid t;
-				std::vector<double> dist;
-				dist.emplace_back(this->alpha);
-				for (auto& d : doc.numTopicByTable) dist.emplace_back(d.num);
-				std::discrete_distribution<Tid> ddist{ dist.begin(), dist.end() };
-				t = ddist(rgs);
-				if (t == 0)
-				{
-					// new table
-					Tid k = g.theta(rgs);
-					t = doc.addNewTable(k);
-					++ld.numTableByTopic[k];
-					++ld.totalTable;
+						k = theta(rgs);
+					} while (!isLiveTopic(k));
 				}
 				else
 				{
-					t -= 1;
+					k = g.theta(rgs);
 				}
-				doc.Zs[i] = t;
+				t = doc.addNewTable(k);
+				++ld.numTableByTopic[k];
+				++ld.totalTable;
 			}
+			else
+			{
+				t -= 1;
+			}
+			doc.Zs[i] = t;
 			addWordTo<1>(ld, doc, i, doc.words[i], doc.Zs[i], doc.numTopicByTable[doc.Zs[i]].topic);
 		}
 
@@ -469,10 +458,11 @@ namespace tomoto
 		DEFINE_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 0, gamma);
 		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 1, 0x00010001, gamma);
 
-		HDPModel(size_t initialK = 2, Float _alpha = 0.1, Float _eta = 0.01, Float _gamma = 0.1, size_t _rg = std::random_device{}())
-			: BaseClass(initialK, _alpha, _eta, _rg), gamma(_gamma)
+		HDPModel(const HDPArgs& args)
+			: BaseClass(args), gamma(args.gamma)
 		{
-			if (_gamma <= 0) THROW_ERROR_WITH_INFO(std::runtime_error, text::format("wrong gamma value (gamma = %f)", _gamma));
+			if (gamma <= 0) THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong gamma value (gamma = %f)", gamma));
+			if (args.alpha.size() > 1) THROW_ERROR_WITH_INFO(exc::InvalidArgument, "Asymmetric alpha is not supported at HDP.");
 		}
 
 		size_t getTotalTables() const override
@@ -497,13 +487,21 @@ namespace tomoto
 
 		void setWordPrior(const std::string& word, const std::vector<Float>& priors) override
 		{
-			THROW_ERROR_WITH_INFO(exception::Unimplemented, "HDPModel doesn't provide setWordPrior function.");
+			THROW_ERROR_WITH_INFO(exc::Unimplemented, "HDPModel doesn't provide setWordPrior function.");
 		}
 
-		std::vector<Float> getTopicsByDoc(const _DocType& doc) const
+		std::vector<Float> getTopicsByDoc(const _DocType& doc, bool normalize) const
 		{
 			std::vector<Float> ret(this->K);
-			Eigen::Map<Eigen::Matrix<Float, -1, 1>> { ret.data(), this->K }.array() = doc.numByTopic.array().template cast<Float>() / doc.getSumWordWeight();
+			Eigen::Map<Eigen::Array<Float, -1, 1>> m{ ret.data(), this->K };
+			if (normalize)
+			{
+				m = doc.numByTopic.array().template cast<Float>() / doc.getSumWordWeight();
+			}
+			else
+			{
+				m = doc.numByTopic.array().template cast<Float>();
+			}
 			return ret;
 		}
 
@@ -528,7 +526,11 @@ namespace tomoto
 				liveK++;
 			}
 
-			auto lda = make_unique<LDAModel<_tw, _RandGen>>(liveK, 0.1f, this->eta);
+			LDAArgs args;
+			args.k = liveK;
+			args.alpha[0] = 0.1f;
+			args.eta = this->eta;
+			auto lda = std::make_unique<LDAModel<_tw, _RandGen>>(args);
 			lda->dict = this->dict;
 			
 			for (auto& doc : this->docs)
@@ -551,6 +553,11 @@ namespace tomoto
 			{
 				for (size_t j = 0; j < this->docs[i].Zs.size(); ++j)
 				{
+					if (this->docs[i].Zs[j] == non_topic_id)
+					{
+						lda->docs[i].Zs[j] = non_topic_id;
+						continue;
+					}
 					size_t newTopic = newK[this->docs[i].numTopicByTable[this->docs[i].Zs[j]].topic];
 					while (newTopic == (Tid)-1) newTopic = newK[randomTopic(rng)];
 					lda->docs[i].Zs[j] = newTopic;

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

@@ -20,12 +20,21 @@ namespace tomoto
 		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseDocument, 1, 0x00010001, path);
 	};
 
+	struct HLDAArgs : public LDAArgs
+	{
+		Float gamma = 0.1;
+
+		HLDAArgs()
+		{
+			k = 2;
+		}
+	};
+
 	class IHLDAModel : public ILDAModel
 	{
 	public:
 		using DefaultDocType = DocumentHLDA<TermWeight::one>;
-		static IHLDAModel* create(TermWeight _weight, size_t levelDepth = 1, 
-			Float alpha = 0.1, Float eta = 0.01, Float gamma = 0.1, size_t seed = std::random_device{}(),
+		static IHLDAModel* create(TermWeight _weight, const HLDAArgs& args,
 			bool scalarRng = false);
 
 		virtual Float getGamma() const = 0;

data/vendor/tomotopy/src/TopicModel/HLDAModel.cpp

@@ -2,12 +2,8 @@
 
 namespace tomoto
 {
-	/*template class HLDAModel<TermWeight::one>;
-	template class HLDAModel<TermWeight::idf>;
-	template class HLDAModel<TermWeight::pmi>;*/
-
-	IHLDAModel* IHLDAModel::create(TermWeight _weight, size_t levelDepth, Float _alpha, Float _eta, Float _gamma, size_t seed, bool scalarRng)
+	IHLDAModel* IHLDAModel::create(TermWeight _weight, const HLDAArgs& args, bool scalarRng)
 	{
-		TMT_SWITCH_TW(_weight, scalarRng, HLDAModel, levelDepth, _alpha, _eta, _gamma, seed);
+		TMT_SWITCH_TW(_weight, scalarRng, HLDAModel, args);
 	}
 }

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

@@ -114,8 +114,8 @@ namespace tomoto
 			static constexpr size_t blockSize = 8;
 			std::vector<NCRPNode> nodes;
 			std::vector<uint8_t> levelBlocks;
-			Eigen::Matrix<Float, -1, 1> nodeLikelihoods; // 
-			Eigen::Matrix<Float, -1, 1> nodeWLikelihoods; //
+			Vector nodeLikelihoods; // 
+			Vector nodeWLikelihoods; //
 
 			DEFINE_SERIALIZER(nodes, levelBlocks);
 
@@ -351,6 +351,8 @@ namespace tomoto
 		template<GlobalSampler _gs>
 		void samplePathes(_DocType& doc, ThreadPool* pool, _ModelState& ld, _RandGen& rgs) const
 		{
+			if (!doc.getSumWordWeight()) return;
+
 			if(_gs != GlobalSampler::inference) ld.nt->nodes[doc.path.back()].dropPathOne();
 			ld.nt->template calcNodeLikelihood<_gs == GlobalSampler::train>(gamma, this->K);
 
@@ -433,7 +435,7 @@ namespace tomoto
 		template<bool _asymEta>
 		Float* getZLikelihoods(_ModelState& ld, const _DocType& doc, size_t docId, size_t vid) const
 		{
-			if (_asymEta) THROW_ERROR_WITH_INFO(exception::Unimplemented, "Unimplemented features");
+			if (_asymEta) THROW_ERROR_WITH_INFO(exc::Unimplemented, "Unimplemented features");
 			const size_t V = this->realV;
 			assert(vid < V);
 			auto& zLikelihood = ld.zLikelihood;
@@ -461,7 +463,6 @@ namespace tomoto
 		double getLLDocs(_DocIter _first, _DocIter _last) const
 		{
 			double ll = 0;
-			auto lgammaAlpha = math::lgammaT(this->alpha);
 			for (; _first != _last; ++_first)
 			{
 				auto& doc = *_first;
@@ -472,13 +473,9 @@ namespace tomoto
 				}
 
 				// doc-level distribution
-				ll -= math::lgammaT(doc.getSumWordWeight() + this->alpha * this->K);
-				for (Tid l = 0; l < this->K; ++l)
-				{
-					ll += math::lgammaT(doc.numByTopic[l] + this->alpha) - lgammaAlpha;
-				}
+				ll -= math::lgammaSubt(this->alphas.sum(), doc.getSumWordWeight());
+				ll += math::lgammaSubt(this->alphas.array(), doc.numByTopic.template cast<Float>().array()).sum();
 			}
-			ll += math::lgammaT(this->alpha * this->K) * std::distance(_first, _last);
 			return ll;
 		}
 
@@ -521,7 +518,7 @@ namespace tomoto
 		{
 			sortAndWriteOrder(doc.words, doc.wOrder);
 			doc.numByTopic.init(nullptr, this->K, 1);
-			doc.Zs = tvector<Tid>(wordSize);
+			doc.Zs = tvector<Tid>(wordSize, non_topic_id);
 			doc.path.resize(this->K);
 			for (size_t l = 0; l < this->K; ++l) doc.path[l] = l;
 			
@@ -597,11 +594,11 @@ namespace tomoto
 		DEFINE_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 0, gamma);
 		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 1, 0x00010001, gamma);
 
-		HLDAModel(size_t _levelDepth = 4, Float _alpha = 0.1, Float _eta = 0.01, Float _gamma = 0.1, size_t _rg = std::random_device{}())
-			: BaseClass(_levelDepth, _alpha, _eta, _rg), gamma(_gamma)
+		HLDAModel(const HLDAArgs& args)
+			: BaseClass(args), gamma(args.gamma)
 		{
-			if (_levelDepth == 0 || _levelDepth >= 0x80000000) THROW_ERROR_WITH_INFO(std::runtime_error, text::format("wrong levelDepth value (levelDepth = %zd)", _levelDepth));
-			if (_gamma <= 0) THROW_ERROR_WITH_INFO(std::runtime_error, text::format("wrong gamma value (gamma = %f)", _gamma));
+			if (args.k == 0 || args.k >= 0x80000000) THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong levelDepth value (levelDepth = %zd)", args.k));
+			if (gamma <= 0) THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong gamma value (gamma = %f)", gamma));
 			this->globalState.nt = std::make_shared<detail::NodeTrees>();
 		}
 
@@ -661,7 +658,7 @@ namespace tomoto
 
 		void setWordPrior(const std::string& word, const std::vector<Float>& priors) override
 		{
-			THROW_ERROR_WITH_INFO(exception::Unimplemented, "HLDAModel doesn't provide setWordPrior function.");
+			THROW_ERROR_WITH_INFO(exc::Unimplemented, "HLDAModel doesn't provide setWordPrior function.");
 		}
 	};
 

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

@@ -16,12 +16,15 @@ namespace tomoto
 		DEFINE_SERIALIZER_BASE_WITH_VERSION(BaseDocument, 1);
 	};
 
+	struct HPAArgs : public PAArgs
+	{
+	};
+
 	class IHPAModel : public IPAModel
 	{
 	public:
 		using DefaultDocType = DocumentHPA<TermWeight::one>;
-		static IHPAModel* create(TermWeight _weight, bool _exclusive = false, size_t _K1 = 1, size_t _K2 = 1, 
-			Float _alpha = 50, Float _eta = 0.01, size_t seed = std::random_device{}(),
+		static IHPAModel* create(TermWeight _weight, bool _exclusive, const HPAArgs& args,
 			bool scalarRng = false);
 	};
 }

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

@@ -2,11 +2,7 @@
 
 namespace tomoto
 {
-	/*template class HPAModel<TermWeight::one>;
-	template class HPAModel<TermWeight::idf>;
-	template class HPAModel<TermWeight::pmi>;*/
-
-    IHPAModel* IHPAModel::create(TermWeight _weight, bool _exclusive, size_t _K, size_t _K2, Float _alphaSum, Float _eta, size_t seed, bool scalarRng)
+    IHPAModel* IHPAModel::create(TermWeight _weight, bool _exclusive, const HPAArgs& args, bool scalarRng)
 	{
 		if (_exclusive)
 		{
@@ -14,7 +10,7 @@ namespace tomoto
 		}
 		else
 		{
-			TMT_SWITCH_TW(_weight, scalarRng, HPAModel, _K, _K2, _alphaSum, _eta, seed);
+			TMT_SWITCH_TW(_weight, scalarRng, HPAModel, args);
 		}
 		return nullptr;
 	}

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

@@ -16,7 +16,7 @@ namespace tomoto
 
 		std::array<Eigen::Matrix<WeightType, -1, -1>, 3> numByTopicWord;
 		std::array<Eigen::Matrix<WeightType, -1, 1>, 3> numByTopic;
-		std::array<Eigen::Matrix<Float, -1, 1>, 2> subTmp;
+		std::array<Vector, 2> subTmp;
 
 		Eigen::Matrix<WeightType, -1, -1> numByTopic1_2;
 
@@ -45,10 +45,10 @@ namespace tomoto
 		Float epsilon = 0.00001;
 		size_t iteration = 5;
 
-		//Eigen::Matrix<Float, -1, 1> alphas; // len = (K + 1)
+		//Vector alphas; // len = (K + 1)
 
-		Eigen::Matrix<Float, -1, 1> subAlphaSum; // len = K
-		Eigen::Matrix<Float, -1, -1> subAlphas; // len = K * (K2 + 1)
+		Vector subAlphaSum; // len = K
+		Matrix subAlphas; // len = K * (K2 + 1)
 
 		void optimizeParameters(ThreadPool& pool, _ModelState* localData, _RandGen* rgs)
 		{
@@ -195,7 +195,7 @@ namespace tomoto
 				Float* dist;
 				if (this->etaByTopicWord.size())
 				{
-					THROW_ERROR_WITH_INFO(exception::Unimplemented, "Unimplemented features");
+					THROW_ERROR_WITH_INFO(exc::Unimplemented, "Unimplemented features");
 				}
 				else
 				{
@@ -379,7 +379,7 @@ namespace tomoto
 		void initGlobalState(bool initDocs)
 		{
 			const size_t V = this->realV;
-			this->globalState.zLikelihood = Eigen::Matrix<Float, -1, 1>::Zero(1 + this->K + this->K * K2);
+			this->globalState.zLikelihood = Vector::Zero(1 + this->K + this->K * K2);
 			if (initDocs)
 			{
 				this->globalState.numByTopic1_2 = Eigen::Matrix<WeightType, -1, -1>::Zero(this->K, K2 + 1);
@@ -440,13 +440,37 @@ namespace tomoto
 		DEFINE_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 0, K2, subAlphas, subAlphaSum);
 		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 1, 0x00010001, K2, subAlphas, subAlphaSum);
 
-		HPAModel(size_t _K1 = 1, size_t _K2 = 1, Float _alpha = 0.1, Float _eta = 0.01, size_t _rg = std::random_device{}())
-			: BaseClass(_K1, _alpha, _eta, _rg), K2(_K2)
+		HPAModel(const HPAArgs& args)
+			: BaseClass(args, false), K2(args.k2)
 		{
-			if (_K2 == 0 || _K2 >= 0x80000000) THROW_ERROR_WITH_INFO(std::runtime_error, text::format("wrong K2 value (K2 = %zd)", _K2));
-			this->alphas = Eigen::Matrix<Float, -1, 1>::Constant(_K1 + 1, _alpha);
-			subAlphas = Eigen::Matrix<Float, -1, -1>::Constant(_K1, _K2 + 1, _alpha);
-			subAlphaSum = Eigen::Matrix<Float, -1, 1>::Constant(_K1, (_K2 + 1) * _alpha);
+			if (K2 == 0 || K2 >= 0x80000000) THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong K2 value (K2 = %zd)", K2));
+
+			if (args.alpha.size() == 1)
+			{
+				this->alphas = Vector::Constant(args.k + 1, args.alpha[0]);
+			}
+			else if (args.alpha.size() == args.k + 1)
+			{
+				this->alphas = Eigen::Map<const Vector>(args.alpha.data(), (Eigen::Index)args.alpha.size());
+			}
+			else
+			{
+				THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong alpha value (len = %zd)", args.alpha.size()));
+			}
+
+			if (args.subalpha.size() == 1)
+			{
+				subAlphas = Matrix::Constant(args.k, args.k2 + 1, args.subalpha[0]);
+			}
+			else if (args.subalpha.size() == args.k2 + 1)
+			{
+				subAlphas = Eigen::Map<const Eigen::Matrix<Float, 1, -1>>(args.subalpha.data(), args.subalpha.size()).replicate(args.k, 1);
+			}
+			else
+			{
+				THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong subalpha value (len = %zd)", args.subalpha.size()));
+			}
+			subAlphaSum = subAlphas.rowwise().sum();
 			this->optimInterval = 1;
 		}
 
@@ -455,7 +479,7 @@ namespace tomoto
 
 		void setDirichletEstIteration(size_t iter) override
 		{
-			if (!iter) throw std::invalid_argument("iter must > 0");
+			if (!iter) throw exc::InvalidArgument("iter must > 0");
 			iteration = iter;
 		}
 
@@ -475,20 +499,23 @@ namespace tomoto
 			return ret;
 		}
 
-		std::vector<Float> getSubTopicBySuperTopic(Tid k) const override
+		std::vector<Float> getSubTopicBySuperTopic(Tid k, bool normalize) const override
 		{
+			std::vector<Float> ret(K2);
 			assert(k < this->K);
 			Float sum = this->globalState.numByTopic1_2.row(k).sum() + subAlphaSum[k];
-			Eigen::Matrix<Float, -1, 1> ret = (this->globalState.numByTopic1_2.row(k).array().template cast<Float>() + subAlphas.row(k).array()) / sum;
-			return { ret.data() + 1, ret.data() + K2 + 1 };
+			if (!normalize) sum = 1;
+			Eigen::Map<Eigen::Array<Float, -1, 1>> m{ ret.data(), (Eigen::Index)K2 };
+			m = (this->globalState.numByTopic1_2.row(k).segment(1, K2).array().template cast<Float>() + subAlphas.row(k).segment(1, K2).array()) / sum;
+			return ret;
 		}
 
 		std::vector<std::pair<Tid, Float>> getSubTopicBySuperTopicSorted(Tid k, size_t topN) const override
 		{
-			return extractTopN<Tid>(getSubTopicBySuperTopic(k), topN);
+			return extractTopN<Tid>(getSubTopicBySuperTopic(k, true), topN);
 		}
 
-		std::vector<Float> _getWidsByTopic(Tid k) const
+		std::vector<Float> _getWidsByTopic(Tid k, bool normalize = true) const
 		{
 			const size_t V = this->realV;
 			std::vector<Float> ret(V);
@@ -504,6 +531,7 @@ namespace tomoto
 				}
 			}
 			Float sum = this->globalState.numByTopic[level][k] + V * this->eta;
+			if (!normalize) sum = 1;
 			auto r = this->globalState.numByTopicWord[level].row(k);
 			for (size_t v = 0; v < V; ++v)
 			{
@@ -512,10 +540,12 @@ namespace tomoto
 			return ret;
 		}
 
-		std::vector<Float> getTopicsByDoc(const _DocType& doc) const
+		std::vector<Float> getTopicsByDoc(const _DocType& doc, bool normalize) const
 		{
 			std::vector<Float> ret(1 + this->K + K2);
 			Float sum = doc.getSumWordWeight() + this->alphas.sum();
+			if (!normalize) sum = 1;
+
 			ret[0] = (doc.numByTopic[0] + this->alphas[0]) / sum;
 			for (size_t k = 0; k < this->K; ++k)
 			{
@@ -528,7 +558,7 @@ namespace tomoto
 			return ret;
 		}
 
-		std::vector<Float> getSubTopicsByDoc(const DocumentBase* doc) const override
+		std::vector<Float> getSubTopicsByDoc(const DocumentBase* doc, bool normalize) const override
 		{
 			throw std::runtime_error{ "not applicable" };
 		}
@@ -540,7 +570,7 @@ namespace tomoto
 
 		void setWordPrior(const std::string& word, const std::vector<Float>& priors) override
 		{
-			THROW_ERROR_WITH_INFO(exception::Unimplemented, "HPAModel doesn't provide setWordPrior function.");
+			THROW_ERROR_WITH_INFO(exc::Unimplemented, "HPAModel doesn't provide setWordPrior function.");
 		}
 
 		std::vector<uint64_t> getCountBySuperTopic() const override