tomoto 0.1.4 → 0.2.0

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

@@ -14,19 +14,38 @@ namespace tomoto
 		ShareableMatrix<Float, -1, 1> eta;
 		sample::AliasMethod<> aliasTable;
 
+		RawDoc::MiscType makeMisc(const ITopicModel* tm) const override
+		{
+			RawDoc::MiscType ret = DocumentLDA<_tw>::makeMisc(tm);
+			ret["timepoint"] = (uint32_t)timepoint;
+			return ret;
+		}
+
 		DEFINE_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseDocument, 0, timepoint);
 		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseDocument, 1, 0x00010001, timepoint);
 	};
 
+	struct DTArgs : public LDAArgs
+	{
+		size_t t = 1;
+		Float phi = 0.1;
+		Float shapeA = 0.01;
+		Float shapeB = 0.1;
+		Float shapeC = 0.55;
+		Float etaL2Reg = 0;
+
+		DTArgs()
+		{
+			alpha[0] = 0.1;
+			eta = 0.1;
+		}
+	};
+
     class IDTModel : public ILDAModel
 	{
 	public:
 		using DefaultDocType = DocumentDTM<TermWeight::one>;
-		static IDTModel* create(TermWeight _weight, size_t _K = 1, size_t _T = 1, 
-			Float _alphaVar = 1.0, Float _etaVar = 1.0, Float _phiVar = 1.0, 
-			Float _shapeA = 0.03, Float _shapeB = 0.1, Float _shapeC = 0.55,
-			Float _etaRegL2 = 0,
-			size_t seed = std::random_device{}(),
+		static IDTModel* create(TermWeight _weight, const DTArgs& args,
 			bool scalarRng = false);
 		
 		virtual size_t getT() const = 0;

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

@@ -2,14 +2,8 @@
 
 namespace tomoto
 {
-	/*template class DTModel<TermWeight::one>;
-	template class DTModel<TermWeight::idf>;
-	template class DTModel<TermWeight::pmi>;*/
-
-	IDTModel* IDTModel::create(TermWeight _weight, size_t _K, size_t _T, 
-		Float _alphaVar, Float _etaVar, Float _phiVar,
-		Float _shapeA, Float _shapeB, Float _shapeC, Float _etaRegL2, size_t seed, bool scalarRng)
+	IDTModel* IDTModel::create(TermWeight _weight, const DTArgs& args, bool scalarRng)
 	{
-		TMT_SWITCH_TW(_weight, scalarRng, DTModel, _K, _T, _alphaVar, _etaVar, _phiVar, _shapeA, _shapeB, _shapeC, _etaRegL2, seed);
+		TMT_SWITCH_TW(_weight, scalarRng, DTModel, args);
 	}
 }

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

@@ -45,12 +45,12 @@ namespace tomoto
 
 		uint64_t T;
 		Float shapeA = 0.03f, shapeB = 0.1f, shapeC = 0.55f;
-		const Float alphaVar = 1.f, etaVar = 1.f, phiVar = 1.f, etaRegL2 = 0.0f;
+		Float alphaVar = 1.f, etaVar = 1.f, phiVar = 1.f, etaRegL2 = 0.0f;
 
-		Eigen::Matrix<Float, -1, -1> alphas; // Dim: (Topic, Time)
-		Eigen::Matrix<Float, -1, -1> etaByDoc; // Dim: (Topic, Docs) : Topic distribution by docs(and time)
+		Matrix alphas; // Dim: (Topic, Time)
+		Matrix etaByDoc; // Dim: (Topic, Docs) : Topic distribution by docs(and time)
 		std::vector<uint32_t> numDocsByTime; // Dim: (Time)
-		Eigen::Matrix<Float, -1, -1> phi; // Dim: (Word, Topic * Time)
+		Matrix phi; // Dim: (Word, Topic * Time)
 		std::vector<sample::AliasMethod<>> wordAliasTables; // Dim: (Word * Time)
 
 		template<int _inc>
@@ -84,8 +84,8 @@ namespace tomoto
 			
 			// sampling eta
 			{
-				Eigen::Matrix<Float, -1, 1> estimatedCnt = (doc.eta.array() - doc.eta.maxCoeff()).exp();
-				Eigen::Matrix<Float, -1, 1> etaTmp;
+				Vector estimatedCnt = (doc.eta.array() - doc.eta.maxCoeff()).exp();
+				Vector etaTmp;
 				estimatedCnt *= doc.getSumWordWeight() / estimatedCnt.sum();
 				auto prior = (alphas.col(doc.timepoint) - doc.eta) / std::max(etaVar, eps * 2);
 				auto grad = doc.numByTopic.template cast<Float>() - estimatedCnt;
@@ -181,20 +181,21 @@ namespace tomoto
 		template<typename _DocIter>
 		void _sampleGlobalLevel(ThreadPool* pool, _ModelState*, _RandGen* rgs, _DocIter first, _DocIter last)
 		{
+			if (!this->realV) return;
 			const auto K = this->K;
 			const Float eps = shapeA * (std::pow(shapeB + 1 + this->globalStep, -shapeC));
 
 			// sampling phi
 			for (size_t k = 0; k < K; ++k)
 			{
-				Eigen::Matrix<Float, -1, -1> phiGrad{ (Eigen::Index)this->realV, (Eigen::Index)T };
+				Matrix phiGrad{ (Eigen::Index)this->realV, (Eigen::Index)T };
 				for (size_t t = 0; t < T; ++t)
 				{
 					auto phi_tk = phi.col(k + K * t);
-					Eigen::Matrix<Float, -1, 1> estimatedCnt = (phi_tk.array() - phi_tk.maxCoeff()).exp();
+					Vector estimatedCnt = (phi_tk.array() - phi_tk.maxCoeff()).exp();
 					estimatedCnt *= this->globalState.numByTopic(k, t) / estimatedCnt.sum();
 
-					Eigen::Matrix<Float, -1, 1> grad = this->globalState.numByTopicWord.row(k + K * t).template cast<Float>();
+					Vector grad = this->globalState.numByTopicWord.row(k + K * t).template cast<Float>();
 					grad -= estimatedCnt;
 					auto epsNoise = Eigen::Rand::normal<Eigen::Array<Float, -1, 1>>(this->realV, 1, *rgs) * eps;
 					if (t == 0)
@@ -228,7 +229,7 @@ namespace tomoto
 				}
 			}
 
-			Eigen::Matrix<Float, -1, -1> newAlphas = Eigen::Matrix<Float, -1, -1>::Zero(alphas.rows(), alphas.cols());
+			Matrix newAlphas = Matrix::Zero(alphas.rows(), alphas.cols());
 			for (size_t t = 0; t < T; ++t)
 			{
 				// update alias tables for word proposal
@@ -398,9 +399,9 @@ namespace tomoto
 				this->globalState.numByTopic = Eigen::Matrix<WeightType, -1, -1>::Zero(this->K, T);
 				this->globalState.numByTopicWord = Eigen::Matrix<WeightType, -1, -1>::Zero(this->K * T, V);
 
-				alphas = Eigen::Matrix<Float, -1, -1>::Zero(this->K, T);
-				etaByDoc = Eigen::Matrix<Float, -1, -1>::Zero(this->K, this->docs.size());
-				phi = Eigen::Matrix<Float, -1, -1>::Zero(this->realV, this->K * T);
+				alphas = Matrix::Zero(this->K, T);
+				etaByDoc = Matrix::Zero(this->K, this->docs.size());
+				phi = Matrix::Zero(this->realV, this->K * T);
 			}
 
 			numDocsByTime.resize(T);
@@ -418,7 +419,7 @@ namespace tomoto
 
 			for (Tid t = 0; t < T; ++t)
 			{
-				if (initDocs && !numDocsByTime[t]) THROW_ERROR_WITH_INFO(exception::InvalidArgument, text::format("No document with timepoint = %d", t));
+				if (initDocs && !numDocsByTime[t]) THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("No document with timepoint = %d", t));
 
 				// update alias tables for word proposal
 				for (Vid v = 0; v < this->realV; ++v)
@@ -439,23 +440,26 @@ namespace tomoto
 			addWordTo<1>(ld, doc, i, w, z);
 		}
 
-		std::vector<Float> _getWidsByTopic(size_t tid) const
+		std::vector<Float> _getWidsByTopic(size_t tid, bool normalize = true) const
 		{
 			const size_t V = this->realV;
 			std::vector<Float> ret(V);
 			Eigen::Map<Eigen::Array<Float, -1, 1>> retMap(ret.data(), V);
 			retMap = phi.col(tid).array().exp();
-			retMap /= retMap.sum();
-			Eigen::Array<Float, -1, 1> t = this->globalState.numByTopicWord.row(tid).array().template cast<Float>();
-			t /= std::max(t.sum(), (Float)0.1);
-			retMap += t;
-			retMap /= 2;
+			if (normalize)
+			{
+				retMap /= retMap.sum();
+				Eigen::Array<Float, -1, 1> t = this->globalState.numByTopicWord.row(tid).array().template cast<Float>();
+				t /= std::max(t.sum(), (Float)0.1);
+				retMap += t;
+				retMap /= 2;
+			}
 			return ret;
 		}
 
 		_DocType& _updateDoc(_DocType& doc, uint32_t timepoint) const
 		{
-			if (timepoint >= T) THROW_ERROR_WITH_INFO(exception::InvalidArgument, "timepoint must < T");
+			if (timepoint >= T) THROW_ERROR_WITH_INFO(exc::InvalidArgument, "timepoint must < T");
 			doc.timepoint = timepoint;
 			return doc;
 		}
@@ -473,6 +477,16 @@ namespace tomoto
 			return cnt;
 		}
 
+		void updateForCopy()
+		{
+			BaseClass::updateForCopy();
+			size_t docId = 0;
+			for (auto& doc : this->docs)
+			{
+				doc.eta.init((Float*)etaByDoc.col(docId++).data(), this->K, 1);
+			}
+		}
+
 	public:
 		DEFINE_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 0, 
 			T, shapeA, shapeB, shapeC, alphaVar, etaVar, phiVar, alphas, etaByDoc, phi);
@@ -489,11 +503,10 @@ namespace tomoto
 		GETTER(ShapeB, Float, shapeB);
 		GETTER(ShapeC, Float, shapeC);
 
-		DTModel(size_t _K, size_t _T, Float _alphaVar, Float _etaVar, Float _phiVar,
-			Float _shapeA, Float _shapeB, Float _shapeC, Float _etaRegL2, size_t _rg)
-			: BaseClass{ _K, _alphaVar, _etaVar, _rg },
-			T{ _T }, alphaVar{ _alphaVar }, etaVar{ _etaVar }, phiVar{ _phiVar },
-			shapeA{ _shapeA }, shapeB{ _shapeB }, shapeC{ _shapeC }, etaRegL2{ _etaRegL2 }
+		DTModel(const DTArgs& args)
+			: BaseClass{ args },
+			T{ args.t }, alphaVar{ args.alpha[0] }, etaVar{ args.eta }, phiVar{ args.phi },
+			shapeA{ args.shapeA }, shapeB{ args.shapeB }, shapeC{ args.shapeC }, etaRegL2{ args.etaL2Reg }
 		{
 		}
 
@@ -506,7 +519,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>(_updateDoc(doc, rawDoc.template getMisc<uint32_t>("timepoint")));
+			return std::make_unique<_DocType>(_updateDoc(doc, rawDoc.template getMisc<uint32_t>("timepoint")));
 		}
 
 		size_t addDoc(const RawDoc& rawDoc) override
@@ -518,7 +531,7 @@ 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>(_updateDoc(doc, rawDoc.template getMisc<uint32_t>("timepoint")));
+			return std::make_unique<_DocType>(_updateDoc(doc, rawDoc.template getMisc<uint32_t>("timepoint")));
 		}
 
 		Float getAlpha(size_t k, size_t t) const override

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

@@ -10,26 +10,52 @@ namespace tomoto
 		using DocumentDMR<_tw>::DocumentDMR;
 		std::vector<Float> metadataOrg, metadataNormalized;
 
+		RawDoc::MiscType makeMisc(const ITopicModel* tm) const override
+		{
+			RawDoc::MiscType ret = DocumentDMR<_tw>::makeMisc(tm);
+			ret["numeric_metadata"] = metadataOrg;
+			return ret;
+		}
+
 		DEFINE_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseDocument, 0, metadataOrg);
 		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseDocument, 1, 0x00010001, metadataOrg, metadataNormalized);
 	};
 
+	struct GDMRArgs : public DMRArgs
+	{
+		std::vector<uint64_t> degrees;
+		Float sigma0 = 3.0;
+		Float orderDecay = 0;
+	};
+
     class IGDMRModel : public IDMRModel
 	{
 	public:
 		using DefaultDocType = DocumentDMR<TermWeight::one>;
-		static IGDMRModel* create(TermWeight _weight, size_t _K = 1, const std::vector<uint64_t>& _degreeByF = {},
-			Float defaultAlpha = 1.0, Float _sigma = 1.0, Float _sigma0 = 1.0, Float _eta = 0.01, Float _alphaEps = 1e-10,
-			size_t seed = std::random_device{}(),
+		static IGDMRModel* create(TermWeight _weight, const GDMRArgs& args,
 			bool scalarRng = false);
 
 		virtual Float getSigma0() const = 0;
+		virtual Float getOrderDecay() const = 0;
 		virtual void setSigma0(Float) = 0;
 		virtual const std::vector<uint64_t>& getFs() const = 0;
 		virtual std::vector<Float> getLambdaByTopic(Tid tid) const = 0;
 
-		virtual std::vector<Float> getTDF(const Float* metadata, bool normalize) const = 0;
-		virtual std::vector<Float> getTDFBatch(const Float* metadata, size_t stride, size_t cnt, bool normalize) const = 0;
+		virtual std::vector<Float> getTDF(
+			const Float* metadata, 
+			const std::string& metadataCat, 
+			const std::vector<std::string>& multiMetadataCat, 
+			bool normalize
+		) const = 0;
+
+		virtual std::vector<Float> getTDFBatch(
+			const Float* metadata, 
+			const std::string& metadataCat, 
+			const std::vector<std::string>& multiMetadataCat,
+			size_t stride, 
+			size_t cnt, 
+			bool normalize
+		) const = 0;
 
 		virtual void setMdRange(const std::vector<Float>& vMin, const std::vector<Float>& vMax) = 0;
 		virtual void getMdRange(std::vector<Float>& vMin, std::vector<Float>& vMax) const = 0;

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

@@ -2,13 +2,8 @@
 
 namespace tomoto
 {
-	/*template class GDMRModel<TermWeight::one>;
-	template class GDMRModel<TermWeight::idf>;
-	template class GDMRModel<TermWeight::pmi>;*/
-
-    IGDMRModel* IGDMRModel::create(TermWeight _weight, size_t _K, const std::vector<uint64_t>& degreeByF, 
-		Float _defaultAlpha, Float _sigma, Float _sigma0, Float _eta, Float _alphaEps, size_t seed, bool scalarRng)
+    IGDMRModel* IGDMRModel::create(TermWeight _weight, const GDMRArgs& args, bool scalarRng)
 	{
-		TMT_SWITCH_TW(_weight, scalarRng, GDMRModel, _K, degreeByF, _defaultAlpha, _sigma, _sigma0, _eta, _alphaEps, seed);
+		TMT_SWITCH_TW(_weight, scalarRng, GDMRModel, args);
 	}
 }

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

@@ -8,8 +8,8 @@ namespace tomoto
 	template<TermWeight _tw>
 	struct ModelStateGDMR : public ModelStateDMR<_tw>
 	{
-		/*Eigen::Matrix<Float, -1, 1> alphas;
-		Eigen::Matrix<Float, -1, 1> terms;
+		/*Vector alphas;
+		Vector terms;
 		std::vector<std::vector<Float>> slpCache;
 		std::vector<size_t> ndimCnt;*/
 	};
@@ -22,7 +22,8 @@ namespace tomoto
 		typename _ModelState = ModelStateGDMR<_tw>>
 	class GDMRModel : public DMRModel<_tw, _RandGen, _Flags, _Interface,
 		typename std::conditional<std::is_same<_Derived, void>::value, GDMRModel<_tw, _RandGen>, _Derived>::type,
-		_DocType, _ModelState>
+		_DocType, _ModelState
+	>
 	{
 	protected:
 		using DerivedClass = typename std::conditional<std::is_same<_Derived, void>::value, GDMRModel<_tw, _RandGen>, _Derived>::type;
@@ -32,51 +33,60 @@ namespace tomoto
 		friend typename BaseClass::BaseClass::BaseClass;
 		using WeightType = typename BaseClass::WeightType;
 
-		Float sigma0 = 3;
+		Float sigma0 = 3, orderDecay = 0;
 		std::vector<Float> mdCoefs, mdIntercepts, mdMax;
 		std::vector<uint64_t> degreeByF;
+		Eigen::Array<Float, -1, 1> orderDecayCached;
+		size_t fCont = 1;
 
-		Float getIntegratedLambdaSq(const Eigen::Ref<const Eigen::Matrix<Float, -1, 1>, 0, Eigen::InnerStride<>>& lambdas) const
+		Float getIntegratedLambdaSq(const Eigen::Ref<const Vector, 0, Eigen::InnerStride<>>& lambdas) const
 		{
-			Float ret = pow(lambdas[0] - log(this->alpha), 2) / 2 / pow(this->sigma0, 2);
-			for (size_t i = 1; i < this->F; ++i)
+			Float ret = 0;
+			for (size_t i = 0; i < this->F; ++i)
 			{
-				ret += pow(lambdas[i], 2) / 2 / pow(this->sigma, 2);
+				ret += pow(lambdas[this->mdVecSize * i] - log(this->alpha), 2) / 2 / pow(this->sigma0, 2);
+				ret += (lambdas.segment(this->mdVecSize * i + 1, fCont - 1).array().pow(2) / 2 * orderDecayCached.segment(1, fCont - 1) / pow(this->sigma, 2)).sum();
+				ret += lambdas.segment(this->mdVecSize * i + fCont, this->mdVecSize - fCont).array().pow(2).sum() / 2 / pow(this->sigma, 2);
 			}
 			return ret;
 		}
 
-		void getIntegratedLambdaSqP(const Eigen::Ref<const Eigen::Matrix<Float, -1, 1>, 0, Eigen::InnerStride<>>& lambdas, 
-			Eigen::Ref<Eigen::Matrix<Float, -1, 1>, 0, Eigen::InnerStride<>> ret) const
+		void getIntegratedLambdaSqP(const Eigen::Ref<const Vector, 0, Eigen::InnerStride<>>& lambdas, 
+			Eigen::Ref<Vector, 0, Eigen::InnerStride<>> ret) const
 		{
-			ret[0] = (lambdas[0] - log(this->alpha)) / pow(this->sigma0, 2);
-			for (size_t i = 1; i < this->F; ++i)
+			for (size_t i = 0; i < this->F; ++i)
 			{
-				ret[i] = lambdas[i] / pow(this->sigma, 2);
+				ret[this->mdVecSize * i] = (lambdas[this->mdVecSize * i] - log(this->alpha)) / pow(this->sigma0, 2);
+				ret.segment(this->mdVecSize * i + 1, fCont - 1) = lambdas.segment(this->mdVecSize * i + 1, fCont - 1).array() * orderDecayCached.segment(1, fCont - 1) / pow(this->sigma, 2);
+				ret.segment(this->mdVecSize * i + fCont, this->mdVecSize - fCont) = lambdas.segment(this->mdVecSize * i + fCont, this->mdVecSize - fCont).array() / pow(this->sigma, 2);
 			}
 		}
 
 		void initParameters()
 		{
-			auto dist0 = std::normal_distribution<Float>(log(this->alpha), sigma0);
-			auto dist = std::normal_distribution<Float>(0, this->sigma);
-			for (size_t i = 0; i < this->K; ++i) for (size_t j = 0; j < this->F; ++j)
+			this->lambda = Eigen::Rand::normalLike(this->lambda, this->rg);
+			
+			for (size_t i = 0; i < this->F; ++i)
 			{
-				if (j == 0)
+				this->lambda.col(this->mdVecSize * i).array() *= sigma0;
+				this->lambda.col(this->mdVecSize * i).array() += log(this->alphas.array());
+
+				for (size_t j = 1; j < fCont; ++j)
 				{
-					this->lambda(i, j) = dist0(this->rg);
+					this->lambda.col(this->mdVecSize * i + j).array() *= this->sigma / std::sqrt(orderDecayCached[j]);
 				}
-				else
+
+				for (size_t j = fCont; j < this->mdVecSize; ++j)
 				{
-					this->lambda(i, j) = dist(this->rg);
+					this->lambda.col(this->mdVecSize * i + j).array() *= this->sigma;
 				}
 			}
 		}
 
-		Float getNegativeLambdaLL(Eigen::Ref<Eigen::Matrix<Float, -1, 1>> x, Eigen::Matrix<Float, -1, 1>& g) const
+		Float getNegativeLambdaLL(Eigen::Ref<Vector> x, Vector& g) const
 		{
-			auto mappedX = Eigen::Map<Eigen::Matrix<Float, -1, -1>>(x.data(), this->K, this->F);
-			auto mappedG = Eigen::Map<Eigen::Matrix<Float, -1, -1>>(g.data(), this->K, this->F);
+			auto mappedX = Eigen::Map<Matrix>(x.data(), this->K, this->F);
+			auto mappedG = Eigen::Map<Matrix>(g.data(), this->K, this->F);
 
 			Float fx = 0;
 			for (size_t k = 0; k < this->K; ++k)
@@ -87,50 +97,51 @@ namespace tomoto
 			return fx;
 		}
 
-		Float evaluateLambdaObj(Eigen::Ref<Eigen::Matrix<Float, -1, 1>> x, Eigen::Matrix<Float, -1, 1>& g, ThreadPool& pool, _ModelState* localData) const
+		/*Float evaluateLambdaObj(Eigen::Ref<Vector> x, Vector& g, ThreadPool& pool, _ModelState* localData) const
 		{
 			// if one of x is greater than maxLambda, return +inf for preventing search more
 			if ((x.array() > this->maxLambda).any()) return INFINITY;
 
 			const auto K = this->K;
-			const auto F = this->F;
+			const auto KF = this->K * this->F;
 
-			auto mappedX = Eigen::Map<Eigen::Matrix<Float, -1, -1>>(x.data(), K, F);
+			auto mappedX = Eigen::Map<Matrix>(x.data(), K, this->F);
 			Float fx = -static_cast<const DerivedClass*>(this)->getNegativeLambdaLL(x, g);
 
-			std::vector<std::future<Eigen::Matrix<Float, -1, 1>>> res;
+			std::vector<std::future<Vector>> res;
 			const size_t chStride = pool.getNumWorkers() * 8;
 			for (size_t ch = 0; ch < chStride; ++ch)
 			{
 				res.emplace_back(pool.enqueue([&, this](size_t threadId)
 				{
 					auto& ld = localData[threadId];
-					thread_local Eigen::Matrix<Float, -1, 1> alphas{ K }, tmpK{ K }, terms{ F };
-					Eigen::Matrix<Float, -1, 1> ret = Eigen::Matrix<Float, -1, 1>::Zero(F * K + 1);
+					thread_local Vector alphas{ K }, tmpK{ K }, terms{ fCont };
+					Vector ret = Vector::Zero(KF + 1);
 					for (size_t docId = ch; docId < this->docs.size(); docId += chStride)
 					{
 						const auto& doc = this->docs[docId];
 						const auto& vx = doc.metadataNormalized;
+						size_t xOffset = doc.metadata * fCont;
 						getTermsFromMd(&vx[0], terms.data());
 						for (Tid k = 0; k < K; ++k)
 						{
-							alphas[k] = exp(mappedX.row(k) * terms) + this->alphaEps;
-							ret[K * F] -= math::lgammaT(alphas[k]) - math::lgammaT(doc.numByTopic[k] + alphas[k]);
-							assert(std::isfinite(ret[K * F]));
+							alphas[k] = exp(mappedX.row(k).segment(xOffset, fCont) * terms) + this->alphaEps;
+							ret[KF] -= math::lgammaT(alphas[k]) - math::lgammaT(doc.numByTopic[k] + alphas[k]);
+							assert(std::isfinite(ret[KF]));
 							if (!std::isfinite(alphas[k]) && alphas[k] > 0) tmpK[k] = 0;
 							else tmpK[k] = -(math::digammaT(alphas[k]) - math::digammaT(doc.numByTopic[k] + alphas[k]));
 						}
 						Float alphaSum = alphas.sum();
-						ret[K * F] += math::lgammaT(alphaSum) - math::lgammaT(doc.getSumWordWeight() + alphaSum);
+						ret[KF] += math::lgammaT(alphaSum) - math::lgammaT(doc.getSumWordWeight() + alphaSum);
 						Float t = math::digammaT(alphaSum) - math::digammaT(doc.getSumWordWeight() + alphaSum);
 						if (!std::isfinite(alphaSum) && alphaSum > 0)
 						{
-							ret[K * F] = -INFINITY;
+							ret[KF] = -INFINITY;
 							t = 0;
 						}
-						for (size_t f = 0; f < F; ++f)
+						for (size_t i = 0; i < fCont; ++i)
 						{
-							ret.segment(f * K, K).array() -= ((tmpK.array() + t) * alphas.array()) * terms[f];
+							ret.segment((i + xOffset) * K, K).array() -= ((tmpK.array() + t) * alphas.array()) * terms[i];
 						}
 						assert(ret.allFinite());
 					}
@@ -140,14 +151,14 @@ namespace tomoto
 			for (auto& r : res)
 			{
 				auto ret = r.get();
-				fx += ret[K * F];
-				g += ret.head(K * F);
+				fx += ret[KF];
+				g += ret.head(KF);
 			}
 
 			// positive fx is an error from limited precision of float.
 			if (fx > 0) return INFINITY;
 			return -fx;
-		}
+		}*/
 
 		void getTermsFromMd(const Float* vx, Float* out, bool normalize = false) const
 		{
@@ -172,7 +183,7 @@ namespace tomoto
 				}
 			}
 
-			for (size_t i = 0; i < this->F; ++i)
+			for (size_t i = 0; i < fCont; ++i)
 			{
 				out[i] = 1;
 				for (size_t n = 0; n < degreeByF.size(); ++n)
@@ -180,47 +191,69 @@ namespace tomoto
 					if(digit[n]) out[i] *= slpCache[n][digit[n] - 1];
 				}
 
-				size_t u;
-				for (u = 0; u < digit.size() && ++digit[u] > degreeByF[u]; ++u)
+				for (size_t u = 0; u < digit.size() && ++digit[u] > degreeByF[u]; ++u)
 				{
 					digit[u] = 0;
 				}
-				u = std::min(u, degreeByF.size() - 1);
 			}
 		}
 
-		template<bool _asymEta>
+		Eigen::Array<Float, -1, 1> calcOrderDecay() const
+		{
+			Eigen::Array<Float, -1, 1> ret{ fCont };
+			std::vector<size_t> digit(degreeByF.size());
+			std::fill(digit.begin(), digit.end(), 0);
+
+			for (size_t i = 0; i < fCont; ++i)
+			{
+				ret[i] = 1;
+				for (size_t n = 0; n < degreeByF.size(); ++n)
+				{
+					ret[i] *= pow(digit[n] + 1, orderDecay * 2);
+				}
+
+				for (size_t u = 0; u < digit.size() && ++digit[u] > degreeByF[u]; ++u)
+				{
+					digit[u] = 0;
+				}
+			}
+			return ret;
+		}
+
+		/*template<bool _asymEta>
 		Float* getZLikelihoods(_ModelState& ld, const _DocType& doc, size_t docId, size_t vid) const
 		{
 			const size_t V = this->realV;
 			assert(vid < V);
 			auto etaHelper = this->template getEtaHelper<_asymEta>();
 			auto& zLikelihood = ld.zLikelihood;
-			thread_local Eigen::Matrix<Float, -1, 1> terms{ this->F };
+			thread_local Vector terms{ fCont };
+			size_t xOffset = doc.metadata * fCont;
 			getTermsFromMd(&doc.metadataNormalized[0], terms.data());
-			zLikelihood = (doc.numByTopic.array().template cast<Float>() + (this->lambda * terms).array().exp() + this->alphaEps)
+			zLikelihood = (doc.numByTopic.array().template cast<Float>() + (this->lambda.middleCols(xOffset, fCont) * terms).array().exp() + this->alphaEps)
 				* (ld.numByTopicWord.col(vid).array().template cast<Float>() + etaHelper.getEta(vid))
 				/ (ld.numByTopic.array().template cast<Float>() + etaHelper.getEtaSum());
 
 			sample::prefixSum(zLikelihood.data(), this->K);
 			return &zLikelihood[0];
-		}
+		}*/
 
-		template<typename _DocIter>
+		/*template<typename _DocIter>
 		double getLLDocs(_DocIter _first, _DocIter _last) const
 		{
 			const auto K = this->K;
 			double ll = 0;
 
-			Eigen::Matrix<Float, -1, 1> alphas(K);
+			Vector alphas(K);
 			for (; _first != _last; ++_first)
 			{
 				auto& doc = *_first;
-				thread_local Eigen::Matrix<Float, -1, 1> terms{ this->F };
+				thread_local Vector terms{ fCont };
 				getTermsFromMd(&doc.metadataNormalized[0], terms.data());
+				size_t xOffset = doc.metadata * fCont;
 				for (Tid k = 0; k < K; ++k)
 				{
-					alphas[k] = exp(this->lambda.row(k) * terms) + this->alphaEps;
+					alphas[k] = exp(this->lambda.row(k).segment(xOffset, fCont) * terms) + this->alphaEps;
 				}
 				Float alphaSum = alphas.sum();
 				for (Tid k = 0; k < K; ++k)
@@ -231,7 +264,7 @@ namespace tomoto
 				ll -= math::lgammaT(doc.getSumWordWeight() + alphaSum) - math::lgammaT(alphaSum);
 			}
 			return ll;
-		}
+		}*/
 
 		double getLLRest(const _ModelState& ld) const
 		{
@@ -296,15 +329,44 @@ namespace tomoto
 
 		void prepareDoc(_DocType& doc, size_t docId, size_t wordSize) const
 		{
-			BaseClass::prepareDoc(doc, docId, wordSize);
+			BaseClass::BaseClass::prepareDoc(doc, docId, wordSize);
 			doc.metadataNormalized = normalizeMetadata(doc.metadataOrg);
+
+			doc.mdVec = Vector::Zero(this->mdVecSize);
+			getTermsFromMd(doc.metadataNormalized.data(), doc.mdVec.data());
+			for (auto x : doc.multiMetadata)
+			{
+				doc.mdVec[fCont + x] = 1;
+			}
+
+			auto p = std::make_pair(doc.metadata, doc.mdVec);
+			auto it = this->mdHashMap.find(p);
+			if (it == this->mdHashMap.end())
+			{
+				it = this->mdHashMap.emplace(p, this->mdHashMap.size()).first;
+			}
+			doc.mdHash = it->second;
 		}
 
 		void initGlobalState(bool initDocs)
 		{
 			BaseClass::BaseClass::initGlobalState(initDocs);
-			this->F = accumulate(degreeByF.begin(), degreeByF.end(), 1, [](size_t a, size_t b) {return a * (b + 1); });
-			if (initDocs) collectMinMaxMetadata();
+			fCont = accumulate(degreeByF.begin(), degreeByF.end(), 1, [](size_t a, size_t b) {return a * (b + 1); });
+			if (!this->metadataDict.size())
+			{
+				this->metadataDict.add("");
+			}
+			this->F = this->metadataDict.size();
+			this->mdVecSize = fCont + this->multiMetadataDict.size();
+			if (initDocs)
+			{
+				collectMinMaxMetadata();
+				this->lambda = Matrix::Zero(this->K, this->F * this->mdVecSize);
+				for (size_t i = 0; i < this->F; ++i)
+				{
+					this->lambda.col(this->mdVecSize * i) = log(this->alphas.array());
+				}
+			}
 			else
 			{
 				// Old binary file has metadataNormalized values into `metadataOrg`
@@ -320,13 +382,28 @@ namespace tomoto
 						}
 					}
 				}
+
+				for (auto& doc : this->docs)
+				{
+					if (doc.mdVec.size() == this->mdVecSize) continue;
+					doc.mdVec = Vector::Zero(this->mdVecSize);
+					getTermsFromMd(doc.metadataNormalized.data(), doc.mdVec.data());
+					for (auto x : doc.multiMetadata)
+					{
+						doc.mdVec[fCont + x] = 1;
+					}
+
+					auto p = std::make_pair(doc.metadata, doc.mdVec);
+					auto it = this->mdHashMap.find(p);
+					if (it == this->mdHashMap.end())
+					{
+						it = this->mdHashMap.emplace(p, this->mdHashMap.size()).first;
+					}
+					doc.mdHash = it->second;
+				}
 			}
 			
-			if (initDocs)
-			{
-				this->lambda = Eigen::Matrix<Float, -1, -1>::Zero(this->K, this->F);
-				this->lambda.col(0).fill(log(this->alpha));
-			}
+			orderDecayCached = calcOrderDecay();
 			LBFGSpp::LBFGSParam<Float> param;
 			param.max_iterations = this->maxBFGSIteration;
 			this->solver = decltype(this->solver){ param };
@@ -334,18 +411,17 @@ namespace tomoto
 
 	public:
 		DEFINE_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 0, sigma0, degreeByF, mdCoefs, mdIntercepts);
-		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 1, 0x00010001, sigma0, degreeByF, mdCoefs, mdIntercepts, mdMax);
+		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 1, 0x00010001, sigma0, orderDecay, degreeByF, mdCoefs, mdIntercepts, mdMax);
 
-		GDMRModel(size_t _K = 1, const std::vector<uint64_t>& _degreeByF = {}, 
-			Float defaultAlpha = 1.0, Float _sigma = 1.0, Float _sigma0 = 1.0, Float _eta = 0.01,
-			Float _alphaEps = 1e-10, size_t _rg = std::random_device{}())
-			: BaseClass(_K, defaultAlpha, _sigma, _eta, _alphaEps, _rg), sigma0(_sigma0), degreeByF(_degreeByF)
+		GDMRModel(const GDMRArgs& args)
+			: BaseClass(args), sigma0(args.sigma0), orderDecay(args.orderDecay), degreeByF(args.degrees)
 		{
-			this->F = accumulate(degreeByF.begin(), degreeByF.end(), 1, [](size_t a, size_t b) {return a * (b + 1); });
+			fCont = accumulate(degreeByF.begin(), degreeByF.end(), 1, [](size_t a, size_t b) {return a * (b + 1); });
 		}
 
 		GETTER(Fs, const std::vector<uint64_t>&, degreeByF);
 		GETTER(Sigma0, Float, sigma0);
+		GETTER(OrderDecay, Float, orderDecay);
 
 		void setSigma0(Float _sigma0) override
 		{
@@ -353,73 +429,94 @@ namespace tomoto
 		}
 
 		template<bool _const = false>
-		_DocType& _updateDoc(_DocType& doc, const std::vector<Float>& metadata) const
+		_DocType& _updateDoc(_DocType& doc, const std::vector<Float>& metadata, const std::string& metadataCat = {}, const std::vector<std::string>& mdVec = {})
 		{
 			if (metadata.size() != degreeByF.size()) 
-				throw std::invalid_argument{ "a length of `metadata` should be equal to a length of `degrees`" };
+				throw exc::InvalidArgument{ "a length of `metadata` should be equal to a length of `degrees`" };
 			doc.metadataOrg = metadata;
+			
+			Vid xid;
+			if (_const)
+			{
+				xid = this->metadataDict.toWid(metadataCat);
+				if (xid == non_vocab_id) throw exc::InvalidArgument("unknown metadata '" + metadataCat + "'");
+
+				for (auto& m : mdVec)
+				{
+					Vid x = this->multiMetadataDict.toWid(m);
+					if (x == non_vocab_id) throw exc::InvalidArgument("unknown multi_metadata '" + m + "'");
+					doc.multiMetadata.emplace_back(x);
+				}
+			}
+			else
+			{
+				xid = this->metadataDict.add(metadataCat);
+
+				for (auto& m : mdVec)
+				{
+					doc.multiMetadata.emplace_back(this->multiMetadataDict.add(m));
+				}
+			}
+			doc.metadata = xid;
 			return doc;
 		}
 
 		size_t addDoc(const RawDoc& rawDoc, const RawDocTokenizer::Factory& tokenizer) override
 		{
 			auto doc = this->template _makeFromRawDoc<false>(rawDoc, tokenizer);
-			return this->_addDoc(_updateDoc(doc, rawDoc.template getMisc<std::vector<Float>>("metadata")));
+			return this->_addDoc(_updateDoc(doc, 
+				rawDoc.template getMisc<std::vector<Float>>("numeric_metadata"),
+				rawDoc.template getMiscDefault<std::string>("metadata"),
+				rawDoc.template getMiscDefault<std::vector<std::string>>("multi_metadata")
+			));
 		}
 
 		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 getMisc<std::vector<Float>>("metadata")));
+			return std::make_unique<_DocType>(as_mutable(this)->template _updateDoc<true>(doc,
+				rawDoc.template getMisc<std::vector<Float>>("numeric_metadata"),
+				rawDoc.template getMiscDefault<std::string>("metadata"),
+				rawDoc.template getMiscDefault<std::vector<std::string>>("multi_metadata")
+			));
 		}
 
 		size_t addDoc(const RawDoc& rawDoc) override
 		{
 			auto doc = this->_makeFromRawDoc(rawDoc);
-			return this->_addDoc(_updateDoc(doc, rawDoc.template getMisc<std::vector<Float>>("metadata")));
+			return this->_addDoc(_updateDoc(doc, 
+				rawDoc.template getMisc<std::vector<Float>>("numeric_metadata"),
+				rawDoc.template getMiscDefault<std::string>("metadata"),
+				rawDoc.template getMiscDefault<std::vector<std::string>>("multi_metadata")
+			));
 		}
 
 		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 getMisc<std::vector<Float>>("metadata")));
+			return std::make_unique<_DocType>(as_mutable(this)->template _updateDoc<true>(doc,
+				rawDoc.template getMisc<std::vector<Float>>("numeric_metadata"),
+				rawDoc.template getMiscDefault<std::string>("metadata"),
+				rawDoc.template getMiscDefault<std::vector<std::string>>("multi_metadata")
+			));
 		}
 
-		std::vector<Float> getTopicsByDoc(const _DocType& doc) const
+		std::vector<Float> getTDF(const Float* metadata, const std::string& metadataCat, const std::vector<std::string>& multiMetadataCat, bool normalize) const override
 		{
-			Eigen::Matrix<Float, -1, 1> alphas(this->K);
-			thread_local Eigen::Matrix<Float, -1, 1> terms{ this->F };
-			getTermsFromMd(&doc.metadataNormalized[0], terms.data());
-			for (Tid k = 0; k < this->K; ++k)
-			{
-				alphas[k] = exp(this->lambda.row(k) * terms) + this->alphaEps;
-			}
-			std::vector<Float> ret(this->K);
-			Float sum = doc.getSumWordWeight() + alphas.sum();
-			for (size_t k = 0; k < this->K; ++k)
-			{
-				ret[k] = (doc.numByTopic[k] + alphas[k]) / sum;
-			}
-			return ret;
-		}
-
-		std::vector<Float> getLambdaByTopic(Tid tid) const override
-		{
-			std::vector<Float> ret(this->F);
-			if (this->lambda.size())
+			Vector terms = Vector::Zero(this->mdVecSize);
+			getTermsFromMd(metadata, terms.data(), true);
+			for (auto& s : multiMetadataCat)
 			{
-				Eigen::Map<Eigen::Matrix<Float, -1, 1>>{ ret.data(), (Eigen::Index)ret.size() } = this->lambda.row(tid);
+				Vid x = this->multiMetadataDict.toWid(s);
+				if (x == non_vocab_id) throw exc::InvalidArgument("unknown multi_metadata " + text::quote(s));
+				terms[fCont + x] = 1;
 			}
-			return ret;
-		}
+			Vid x = this->metadataDict.toWid(metadataCat);
+			if (x == non_vocab_id) throw exc::InvalidArgument("unknown metadata " + text::quote(metadataCat));
 
-		std::vector<Float> getTDF(const Float* metadata, bool normalize) const override
-		{
-			Eigen::Matrix<Float, -1, 1> terms{ this->F };
-			getTermsFromMd(metadata, terms.data(), true);
 			std::vector<Float> ret(this->K);
 			Eigen::Map<Eigen::Array<Float, -1, 1>> retMap{ ret.data(), (Eigen::Index)ret.size() };
-			retMap = (this->lambda * terms).array();
+			retMap = (this->lambda.middleCols(x * this->mdVecSize, this->mdVecSize) * terms).array();
 			if (normalize)
 			{
 				retMap = (retMap - retMap.maxCoeff()).exp();
@@ -428,16 +525,25 @@ namespace tomoto
 			return ret;
 		}
 
-		std::vector<Float> getTDFBatch(const Float* metadata, size_t stride, size_t cnt, bool normalize) const override
+		std::vector<Float> getTDFBatch(const Float* metadata, const std::string& metadataCat, const std::vector<std::string>& multiMetadataCat, size_t stride, size_t cnt, bool normalize) const override
 		{
-			Eigen::Matrix<Float, -1, -1> terms{ this->F, (Eigen::Index)cnt };
+			Matrix terms = Matrix::Zero(this->mdVecSize, (Eigen::Index)cnt);
 			for (size_t i = 0; i < cnt; ++i)
 			{
 				getTermsFromMd(metadata + stride * i, terms.col(i).data(), true);
 			}
+			for (auto& s : multiMetadataCat)
+			{
+				Vid x = this->multiMetadataDict.toWid(s);
+				if (x == non_vocab_id) throw exc::InvalidArgument("unknown multi_metadata " + text::quote(s));
+				terms.row(fCont + x).setOnes();
+			}
+			Vid x = this->metadataDict.toWid(metadataCat);
+			if (x == non_vocab_id) throw exc::InvalidArgument("unknown metadata " + text::quote(metadataCat));
+
 			std::vector<Float> ret(this->K * cnt);
 			Eigen::Map<Eigen::Array<Float, -1, -1>> retMap{ ret.data(), (Eigen::Index)this->K, (Eigen::Index)cnt };
-			retMap = (this->lambda * terms).array();
+			retMap = (this->lambda.middleCols(x * this->mdVecSize, this->mdVecSize) * terms).array();
 			if (normalize)
 			{
 				retMap.rowwise() -= retMap.colwise().maxCoeff();
@@ -446,6 +552,7 @@ namespace tomoto
 			}
 			return ret;
 		}
+
 		void setMdRange(const std::vector<Float>& vMin, const std::vector<Float>& vMax) override
 		{
 			mdIntercepts = vMin;