tomoto 0.1.4 → 0.2.0

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

@@ -2,16 +2,8 @@
 
 namespace tomoto
 {
-	/*template class MGLDAModel<TermWeight::one>;
-	template class MGLDAModel<TermWeight::idf>;
-	template class MGLDAModel<TermWeight::pmi>;*/
-
-    IMGLDAModel* IMGLDAModel::create(TermWeight _weight, size_t _KG, size_t _KL, size_t _T,
-		Float _alphaG, Float _alphaL, Float _alphaMG, Float _alphaML,
-		Float _etaG, Float _etaL, Float _gamma, size_t seed, bool scalarRng)
+    IMGLDAModel* IMGLDAModel::create(TermWeight _weight, const MGLDAArgs& args, bool scalarRng)
 	{
-		TMT_SWITCH_TW(_weight, scalarRng, MGLDAModel, _KG, _KL, _T,
-			_alphaG, _alphaL, _alphaMG, _alphaML,
-			_etaG, _etaL, _gamma, seed);
+		TMT_SWITCH_TW(_weight, scalarRng, MGLDAModel, args);
 	}
 }

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

@@ -289,7 +289,7 @@ namespace tomoto
 
 			const size_t S = doc.numBySent.size();
 			std::fill(doc.numBySent.begin(), doc.numBySent.end(), 0);
-			doc.Zs = tvector<Tid>(wordSize);
+			doc.Zs = tvector<Tid>(wordSize, non_topic_id);
 			doc.Vs.resize(wordSize);
 			if (_tw != TermWeight::one) doc.wordWeights.resize(wordSize);
 			doc.numByTopic.init(nullptr, this->K + KL, 1);
@@ -302,7 +302,7 @@ namespace tomoto
 		void initGlobalState(bool initDocs)
 		{
 			const size_t V = this->realV;
-			this->globalState.zLikelihood = Eigen::Matrix<Float, -1, 1>::Zero(T * (this->K + KL));
+			this->globalState.zLikelihood = Vector::Zero(T * (this->K + KL));
 			if (initDocs)
 			{
 				this->globalState.numByTopic = Eigen::Matrix<WeightType, -1, 1>::Zero(this->K + KL);
@@ -371,17 +371,33 @@ namespace tomoto
 		DEFINE_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 0, alphaL, alphaM, alphaML, etaL, gamma, KL, T);
 		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 1, 0x00010001, alphaL, alphaM, alphaML, etaL, gamma, KL, T);
 
-		MGLDAModel(size_t _KG = 1, size_t _KL = 1, size_t _T = 3,
-			Float _alphaG = 0.1, Float _alphaL = 0.1, Float _alphaMG = 0.1, Float _alphaML = 0.1,
-			Float _etaG = 0.01, Float _etaL = 0.01, Float _gamma = 0.1, size_t _rg = std::random_device{}())
-			: BaseClass(_KG, _alphaG, _etaG, _rg), KL(_KL), T(_T),
-			alphaL(_alphaL), alphaM(_KG ? _alphaMG : 0), alphaML(_alphaML),
-			etaL(_etaL), gamma(_gamma)
+		MGLDAModel(const MGLDAArgs& args)
+			: BaseClass(args), KL(args.kL), T(args.t),
+			alphaL(args.alphaL[0]), alphaM(args.k ? args.alphaMG : 0), alphaML(args.alphaML),
+			etaL(args.etaL), gamma(args.gamma)
 		{
-			if (_KL == 0 || _KL >= 0x80000000) THROW_ERROR_WITH_INFO(std::runtime_error, text::format("wrong KL value (KL = %zd)", _KL));
-			if (_T == 0 || _T >= 0x80000000) THROW_ERROR_WITH_INFO(std::runtime_error, text::format("wrong T value (T = %zd)", _T));
-			if (_alphaL <= 0) THROW_ERROR_WITH_INFO(std::runtime_error, text::format("wrong alphaL value (alphaL = %f)", _alphaL));
-			if (_etaL <= 0) THROW_ERROR_WITH_INFO(std::runtime_error, text::format("wrong etaL value (etaL = %f)", _etaL));
+			if (KL == 0 || KL >= 0x80000000) THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong KL value (KL = %zd)", KL));
+			if (T == 0 || T >= 0x80000000) THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong T value (T = %zd)", T));
+
+			if (args.alpha.size() != 1)
+			{
+				THROW_ERROR_WITH_INFO(exc::Unimplemented, "An asymmetric alpha prior is not supported yet at MGLDA.");
+			}
+
+			if (args.alphaL.size() == 1)
+			{
+			}
+			else if (args.alphaL.size() == args.kL)
+			{
+				THROW_ERROR_WITH_INFO(exc::Unimplemented, "An asymmetric alphaL prior is not supported yet at MGLDA.");
+			}
+			else
+			{
+				THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong alphaL value (len = %zd)", args.alphaL.size()));
+			}
+
+			if (alphaL <= 0) THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong alphaL value (alphaL = %f)", alphaL));
+			if (etaL <= 0) THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong etaL value (etaL = %f)", etaL));
 		}
 
 		template<bool _const, typename _FnTokenizer>
@@ -426,7 +442,7 @@ namespace tomoto
 
 		std::unique_ptr<DocumentBase> makeDoc(const RawDoc& rawDoc, const RawDocTokenizer::Factory& tokenizer) const
 		{
-			return make_unique<_DocType>(as_mutable(this)->template _makeFromRawDoc<true>(rawDoc, tokenizer, rawDoc.template getMisc<std::string>("delimiter")));
+			return std::make_unique<_DocType>(as_mutable(this)->template _makeFromRawDoc<true>(rawDoc, tokenizer, rawDoc.template getMisc<std::string>("delimiter")));
 		}
 
 		template<bool _const = false>
@@ -497,25 +513,32 @@ namespace tomoto
 
 		std::unique_ptr<DocumentBase> makeDoc(const RawDoc& rawDoc) const
 		{
-			return make_unique<_DocType>(as_mutable(this)->template _makeFromRawDoc<true>(rawDoc));
+			return std::make_unique<_DocType>(as_mutable(this)->template _makeFromRawDoc<true>(rawDoc));
 		}
 
 		void setWordPrior(const std::string& word, const std::vector<Float>& priors) override
 		{
-			if (priors.size() != this->K + KL) THROW_ERROR_WITH_INFO(exception::InvalidArgument, "priors.size() must be equal to K.");
+			if (priors.size() != this->K + KL) THROW_ERROR_WITH_INFO(exc::InvalidArgument, "priors.size() must be equal to K.");
 			for (auto p : priors)
 			{
-				if (p < 0) THROW_ERROR_WITH_INFO(exception::InvalidArgument, "priors must not be less than 0.");
+				if (p < 0) THROW_ERROR_WITH_INFO(exc::InvalidArgument, "priors must not be less than 0.");
 			}
 			this->dict.add(word);
 			this->etaByWord.emplace(word, priors);
 		}
 
-		std::vector<Float> getTopicsByDoc(const _DocType& doc) const
+		std::vector<Float> getTopicsByDoc(const _DocType& doc, bool normalize) const
 		{
 			std::vector<Float> ret(this->K + KL);
-			Eigen::Map<Eigen::Matrix<Float, -1, 1>> { ret.data(), this->K + KL }.array() =
-				doc.numByTopic.array().template cast<Float>() / doc.getSumWordWeight();
+			Eigen::Map<Eigen::Array<Float, -1, 1>> m{ ret.data(), this->K + KL };
+			if (normalize)
+			{
+				m = doc.numByTopic.array().template cast<Float>() / doc.getSumWordWeight();
+			}
+			else
+			{
+				m = doc.numByTopic.array().template cast<Float>();
+			}
 			return ret;
 		}
 

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

@@ -18,13 +18,18 @@ namespace tomoto
 		DEFINE_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseDocument, 0, Z2s);
 		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseDocument, 1, 0x00010001, Z2s);
 	};
+
+	struct PAArgs : public LDAArgs
+	{
+		size_t k2 = 1;
+		std::vector<Float> subalpha = { 0.1 };
+	};
     
     class IPAModel : public ILDAModel
 	{
 	public:
 		using DefaultDocType = DocumentPA<TermWeight::one>;
-		static IPAModel* create(TermWeight _weight, size_t _K1 = 1, size_t _K2 = 1, 
-			Float _alpha = 0.1, Float _eta = 0.01, size_t seed = std::random_device{}(),
+		static IPAModel* create(TermWeight _weight, const PAArgs& args,
 			bool scalarRng = false);
 
 		virtual size_t getDirichletEstIteration() const = 0;
@@ -32,10 +37,10 @@ namespace tomoto
 		virtual size_t getK2() const = 0;
 		virtual Float getSubAlpha(Tid k1, Tid k2) const = 0;
 		virtual std::vector<Float> getSubAlpha(Tid k1) const = 0;
-		virtual std::vector<Float> getSubTopicBySuperTopic(Tid k) const = 0;
+		virtual std::vector<Float> getSubTopicBySuperTopic(Tid k, bool normalize = true) const = 0;
 		virtual std::vector<std::pair<Tid, Float>> getSubTopicBySuperTopicSorted(Tid k, size_t topN) const = 0;
 
-		virtual std::vector<Float> getSubTopicsByDoc(const DocumentBase* doc) const = 0;
+		virtual std::vector<Float> getSubTopicsByDoc(const DocumentBase* doc, bool normalize = true) const = 0;
 		virtual std::vector<std::pair<Tid, Float>> getSubTopicsByDocSorted(const DocumentBase* doc, size_t topN) const = 0;
 
 		virtual std::vector<uint64_t> getCountBySuperTopic() const = 0;

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

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

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

@@ -16,7 +16,7 @@ namespace tomoto
 		using WeightType = typename ModelStateLDA<_tw>::WeightType;
 		Eigen::Matrix<WeightType, -1, -1> numByTopic1_2;
 		Eigen::Matrix<WeightType, -1, 1> numByTopic2;
-		Eigen::Matrix<Float, -1, 1> subTmp;
+		Vector subTmp;
 
 		DEFINE_SERIALIZER_AFTER_BASE(ModelStateLDA<_tw>, numByTopic1_2, numByTopic2);
 	};
@@ -41,8 +41,8 @@ namespace tomoto
 		Float epsilon = 1e-5;
 		size_t iteration = 5;
 
-		Eigen::Matrix<Float, -1, 1> subAlphaSum; // len = K
-		Eigen::Matrix<Float, -1, -1> subAlphas; // len = K * K2
+		Vector subAlphaSum; // len = K
+		Matrix subAlphas; // len = K * K2
 		void optimizeParameters(ThreadPool& pool, _ModelState* localData, _RandGen* rgs)
 		{
 			const auto K = this->K;
@@ -286,7 +286,7 @@ namespace tomoto
 			BaseClass::prepareDoc(doc, docId, wordSize);
 
 			doc.numByTopic1_2 = Eigen::Matrix<WeightType, -1, -1>::Zero(this->K, K2);
-			doc.Z2s = tvector<Tid>(wordSize);
+			doc.Z2s = tvector<Tid>(wordSize, non_topic_id);
 		}
 
 		void prepareWordPriors()
@@ -299,7 +299,7 @@ namespace tomoto
 			{
 				auto id = this->dict.toWid(it.first);
 				if (id == (Vid)-1 || id >= this->realV) continue;
-				this->etaByTopicWord.col(id) = Eigen::Map<Eigen::Matrix<Float, -1, 1>>{ it.second.data(), (Eigen::Index)it.second.size() };
+				this->etaByTopicWord.col(id) = Eigen::Map<Vector>{ it.second.data(), (Eigen::Index)it.second.size() };
 			}
 			this->etaSumByTopic = this->etaByTopicWord.rowwise().sum();
 		}
@@ -307,7 +307,7 @@ namespace tomoto
 		void initGlobalState(bool initDocs)
 		{
 			const size_t V = this->realV;
-			this->globalState.zLikelihood = Eigen::Matrix<Float, -1, 1>::Zero(this->K * K2);
+			this->globalState.zLikelihood = Vector::Zero(this->K * K2);
 			if (initDocs)
 			{
 				this->globalState.numByTopic = Eigen::Matrix<WeightType, -1, 1>::Zero(this->K);
@@ -365,12 +365,24 @@ 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);
 
-		PAModel(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)
+		PAModel(const PAArgs& args)
+			: BaseClass(args), K2(args.k2)
 		{
-			if (_K2 == 0 || _K2 >= 0x80000000) THROW_ERROR_WITH_INFO(std::runtime_error, text::format("wrong K2 value (K2 = %zd)", _K2));
-			subAlphaSum = Eigen::Matrix<Float, -1, 1>::Constant(_K1, _K2 * 0.1);
-			subAlphas = Eigen::Matrix<Float, -1, -1>::Constant(_K1, _K2, 0.1);
+			if (K2 == 0 || K2 >= 0x80000000) THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong K2 value (K2 = %zd)", K2));
+
+			if (args.subalpha.size() == 1)
+			{
+				subAlphas = Matrix::Constant(args.k, args.k2, args.subalpha[0]);
+			}
+			else if(args.subalpha.size() == args.k2)
+			{
+				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;
 		}
 
@@ -379,7 +391,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;
 		}
 
@@ -392,43 +404,54 @@ namespace tomoto
 			return ret;
 		}
 
-		std::vector<Float> getSubTopicBySuperTopic(Tid k) const override
+		std::vector<Float> getSubTopicBySuperTopic(Tid k, bool normalize) const override
 		{
 			assert(k < this->K);
+			std::vector<Float> ret(K2);
 			Float sum = this->globalState.numByTopic[k] + 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(), ret.data() + K2 };
+			if (!normalize) sum = 1;
+			Eigen::Map<Eigen::Array<Float, -1, 1>> m{ ret.data(), K2 };
+			m = (this->globalState.numByTopic1_2.row(k).array().template cast<Float>() + subAlphas.row(k).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> getSubTopicsByDoc(const _DocType& doc) const
+		std::vector<Float> getSubTopicsByDoc(const _DocType& doc, bool normalize) const
 		{
 			std::vector<Float> ret(K2);
-			Eigen::Map<Eigen::Matrix<Float, -1, 1>> { ret.data(), K2 }.array() =
-				((doc.numByTopic1_2.array().template cast<Float>() + subAlphas.array()).colwise().sum()) / (doc.getSumWordWeight() + subAlphas.sum());
+			Eigen::Map<Eigen::Array<Float, -1, 1>> m{ ret.data(), K2 };
+			if (normalize)
+			{
+				m = ((doc.numByTopic1_2.array().template cast<Float>() + subAlphas.array()).colwise().sum()) / (doc.getSumWordWeight() + subAlphas.sum());
+			}
+			else
+			{
+				m = (doc.numByTopic1_2.array().template cast<Float>() + subAlphas.array()).colwise().sum();
+			}
 			return ret;
 		}
 
-		std::vector<Float> getSubTopicsByDoc(const DocumentBase* doc) const override
+		std::vector<Float> getSubTopicsByDoc(const DocumentBase* doc, bool normalize) const override
 		{
-			return static_cast<const DerivedClass*>(this)->getSubTopicsByDoc(*static_cast<const _DocType*>(doc));
+			return static_cast<const DerivedClass*>(this)->getSubTopicsByDoc(*static_cast<const _DocType*>(doc), normalize);
 		}
 
 		std::vector<std::pair<Tid, Float>> getSubTopicsByDocSorted(const DocumentBase* doc, size_t topN) const override
 		{
-			return extractTopN<Tid>(getSubTopicsByDoc(doc), topN);
+			return extractTopN<Tid>(getSubTopicsByDoc(doc, true), topN);
 		}
 
-		std::vector<Float> _getWidsByTopic(Tid k2) const
+		std::vector<Float> _getWidsByTopic(Tid k2, bool normalize = true) const
 		{
 			assert(k2 < K2);
 			const size_t V = this->realV;
 			std::vector<Float> ret(V);
 			Float sum = this->globalState.numByTopic2[k2] + V * this->eta;
+			if (!normalize) sum = 1;
 			auto r = this->globalState.numByTopicWord.row(k2);
 			for (size_t v = 0; v < V; ++v)
 			{
@@ -439,10 +462,10 @@ namespace tomoto
 
 		void setWordPrior(const std::string& word, const std::vector<Float>& priors) override
 		{
-			if (priors.size() != K2) THROW_ERROR_WITH_INFO(exception::InvalidArgument, "priors.size() must be equal to K2.");
+			if (priors.size() != K2) THROW_ERROR_WITH_INFO(exc::InvalidArgument, "priors.size() must be equal to K2.");
 			for (auto p : priors)
 			{
-				if (p < 0) THROW_ERROR_WITH_INFO(exception::InvalidArgument, "priors must not be less than 0.");
+				if (p < 0) THROW_ERROR_WITH_INFO(exc::InvalidArgument, "priors must not be less than 0.");
 			}
 			this->dict.add(word);
 			this->etaByWord.emplace(word, priors);

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

@@ -3,13 +3,24 @@
 
 namespace tomoto
 {
+	struct PLDAArgs : public LDAArgs
+	{
+		size_t numLatentTopics = 0;
+		size_t numTopicsPerLabel = 1;
+
+		PLDAArgs setK(size_t _k = 1) const
+		{
+			PLDAArgs ret = *this;
+			ret.k = _k;
+			return ret;
+		}
+	};
 
 	class IPLDAModel : public ILLDAModel
 	{
 	public:
 		using DefaultDocType = DocumentLLDA<TermWeight::one>;
-		static IPLDAModel* create(TermWeight _weight, size_t _numLatentTopics = 0, size_t _numTopicsPerLabel = 1,
-			Float alpha = 0.1, Float eta = 0.01, size_t seed = std::random_device{}(),
+		static IPLDAModel* create(TermWeight _weight, const PLDAArgs& args,
 			bool scalarRng = false);
 
 		virtual size_t getNumLatentTopics() const = 0;

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

@@ -2,12 +2,8 @@
 
 namespace tomoto
 {
-	/*template class PLDAModel<TermWeight::one>;
-	template class PLDAModel<TermWeight::idf>;
-	template class PLDAModel<TermWeight::pmi>;*/
-
-	IPLDAModel* IPLDAModel::create(TermWeight _weight, size_t _numLatentTopics, size_t _numTopicsPerLabel, Float _alpha, Float _eta, size_t seed, bool scalarRng)
+	IPLDAModel* IPLDAModel::create(TermWeight _weight, const PLDAArgs& args, bool scalarRng)
 	{
-		TMT_SWITCH_TW(_weight, scalarRng, PLDAModel, _numLatentTopics, _numTopicsPerLabel, _alpha, _eta, seed);
+		TMT_SWITCH_TW(_weight, scalarRng, PLDAModel, args);
 	}
 }

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

@@ -75,14 +75,16 @@ namespace tomoto
 
 		struct Generator
 		{
-			std::discrete_distribution<> theta;
+			Eigen::Array<Float, -1, 1> p;
+			Eigen::Rand::DiscreteGen<int32_t> theta;
 		};
 
 		Generator makeGeneratorForInit(const _DocType* doc) const
 		{
-			return Generator{ 
-				std::discrete_distribution<>{ doc->labelMask.data(), doc->labelMask.data() + doc->labelMask.size() } 
-			};
+			Generator g;
+			g.p = doc->labelMask.array().template cast<Float>() * this->alphas.array();
+			g.theta = Eigen::Rand::DiscreteGen<int32_t>{ g.p.data(), g.p.data() + this->K };
+			return g;
 		}
 
 		template<bool _Infer>
@@ -93,7 +95,7 @@ namespace tomoto
 			if (this->etaByTopicWord.size())
 			{
 				Eigen::Array<Float, -1, 1> col = this->etaByTopicWord.col(w);
-				for (size_t k = 0; k < col.size(); ++k) col[k] *= g.theta.probabilities()[k];
+				col *= g.p;
 				z = sample::sampleFromDiscrete(col.data(), col.data() + col.size(), rgs);
 			}
 			else
@@ -107,15 +109,14 @@ namespace tomoto
 		DEFINE_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 0, topicLabelDict, numLatentTopics, numTopicsPerLabel);
 		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 1, 0x00010001, topicLabelDict, numLatentTopics, numTopicsPerLabel);
 
-		PLDAModel(size_t _numLatentTopics = 0, size_t _numTopicsPerLabel = 1, 
-			Float _alpha = 1.0, Float _eta = 0.01, size_t _rg = std::random_device{}())
-			: BaseClass(1, _alpha, _eta, _rg), 
-			numLatentTopics(_numLatentTopics), numTopicsPerLabel(_numTopicsPerLabel)
+		PLDAModel(const PLDAArgs& args)
+			: BaseClass(args.setK(1)),
+			numLatentTopics(args.numLatentTopics), numTopicsPerLabel(args.numTopicsPerLabel)
 		{
-			if (_numLatentTopics >= 0x80000000) 
-				THROW_ERROR_WITH_INFO(std::runtime_error, text::format("wrong numLatentTopics value (numLatentTopics = %zd)", _numLatentTopics));
-			if (_numTopicsPerLabel == 0 || _numTopicsPerLabel >= 0x80000000) 
-				THROW_ERROR_WITH_INFO(std::runtime_error, text::format("wrong numTopicsPerLabel value (numTopicsPerLabel = %zd)", _numTopicsPerLabel));
+			if (numLatentTopics >= 0x80000000)
+				THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong numLatentTopics value (numLatentTopics = %zd)", numLatentTopics));
+			if (numTopicsPerLabel == 0 || numTopicsPerLabel >= 0x80000000)
+				THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong numTopicsPerLabel value (numTopicsPerLabel = %zd)", numTopicsPerLabel));
 		}
 
 		template<bool _const = false>
@@ -162,7 +163,7 @@ namespace tomoto
 		std::unique_ptr<DocumentBase> makeDoc(const RawDoc& rawDoc, const RawDocTokenizer::Factory& tokenizer) const override
 		{
 			auto doc = as_mutable(this)->template _makeFromRawDoc<true>(rawDoc, tokenizer);
-			return make_unique<_DocType>(as_mutable(this)->template _updateDoc<true>(doc, rawDoc.template getMiscDefault<std::vector<std::string>>("labels")));
+			return std::make_unique<_DocType>(as_mutable(this)->template _updateDoc<true>(doc, rawDoc.template getMiscDefault<std::vector<std::string>>("labels")));
 		}
 
 		size_t addDoc(const RawDoc& rawDoc) override
@@ -174,16 +175,23 @@ namespace tomoto
 		std::unique_ptr<DocumentBase> makeDoc(const RawDoc& rawDoc) const override
 		{
 			auto doc = as_mutable(this)->template _makeFromRawDoc<true>(rawDoc);
-			return make_unique<_DocType>(as_mutable(this)->template _updateDoc<true>(doc, rawDoc.template getMiscDefault<std::vector<std::string>>("labels")));
+			return std::make_unique<_DocType>(as_mutable(this)->template _updateDoc<true>(doc, rawDoc.template getMiscDefault<std::vector<std::string>>("labels")));
 		}
 
-		std::vector<Float> getTopicsByDoc(const _DocType& doc) const
+		std::vector<Float> getTopicsByDoc(const _DocType& doc, bool normalize) const
 		{
 			std::vector<Float> ret(this->K);
 			auto maskedAlphas = this->alphas.array() * doc.labelMask.template cast<Float>().array();
-			Eigen::Map<Eigen::Matrix<Float, -1, 1>> { ret.data(), this->K }.array() =
-				(doc.numByTopic.array().template cast<Float>() + maskedAlphas)
-				/ (doc.getSumWordWeight() + maskedAlphas.sum());
+			Eigen::Map<Eigen::Array<Float, -1, 1>> m{ ret.data(), this->K };
+			if (normalize)
+			{
+				m = (doc.numByTopic.array().template cast<Float>() + maskedAlphas)
+					/ (doc.getSumWordWeight() + maskedAlphas.sum());
+			}
+			else
+			{
+				m = doc.numByTopic.array().template cast<Float>() + maskedAlphas;
+			}
 			return ret;
 		}