tomoto 0.1.4 → 0.2.0

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

@@ -4,7 +4,7 @@
 namespace tomoto
 {
 	template<TermWeight _tw>
-	struct DocumentPTM : public DocumentLDA<_tw>
+	struct DocumentPT : public DocumentLDA<_tw>
 	{
 		using BaseDocument = DocumentLDA<_tw>;
 		using DocumentLDA<_tw>::DocumentLDA;
@@ -16,12 +16,19 @@ namespace tomoto
 		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseDocument, 1, 0x00010001, pseudoDoc);
 	};
 
+	struct PTArgs : public LDAArgs
+	{
+		size_t p = 100;
+		Float lambda = 0.01;
+	};
+
 	class IPTModel : public ILDAModel
 	{
 	public:
-		using DefaultDocType = DocumentPTM<TermWeight::one>;
-		static IPTModel* create(TermWeight _weight, size_t _K = 1, size_t _P = 100, 
-			Float alpha = 0.1, Float eta = 0.01, Float lambda = 0.01, size_t seed = std::random_device{}(),
+		using DefaultDocType = DocumentPT<TermWeight::one>;
+		static IPTModel* create(TermWeight _weight, const PTArgs& args,
 			bool scalarRng = false);
+
+		virtual size_t getP() const = 0;
 	};
-}
+}

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

@@ -2,9 +2,8 @@
 
 namespace tomoto
 {
-
-	IPTModel* IPTModel::create(TermWeight _weight, size_t _K, size_t _P, Float _alpha, Float _eta, Float _lambda, size_t seed, bool scalarRng)
+	IPTModel* IPTModel::create(TermWeight _weight, const PTArgs& args, bool scalarRng)
 	{
-		TMT_SWITCH_TW(_weight, scalarRng, PTModel, _K, _P, _alpha, _eta, _lambda, seed);
+		TMT_SWITCH_TW(_weight, scalarRng, PTModel, args);
 	}
 }

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

@@ -25,7 +25,7 @@ namespace tomoto
 	template<TermWeight _tw, typename _RandGen,
 		typename _Interface = IPTModel,
 		typename _Derived = void,
-		typename _DocType = DocumentPTM<_tw>,
+		typename _DocType = DocumentPT<_tw>,
 		typename _ModelState = ModelStatePTM<_tw>>
 	class PTModel : public LDAModel<_tw, _RandGen, flags::continuous_doc_data | flags::partitioned_multisampling, _Interface,
 		typename std::conditional<std::is_same<_Derived, void>::value, PTModel<_tw, _RandGen>, _Derived>::type,
@@ -158,15 +158,13 @@ namespace tomoto
 		{
 			sortAndWriteOrder(doc.words, doc.wOrder);
 			doc.numByTopic.init((WeightType*)this->globalState.numByTopicPDoc.col(0).data(), this->K, 1);
-			doc.Zs = tvector<Tid>(wordSize);
+			doc.Zs = tvector<Tid>(wordSize, non_topic_id);
 			if (_tw != TermWeight::one) doc.wordWeights.resize(wordSize);
 		}
 
 		void initGlobalState(bool initDocs)
 		{
-			this->alphas.resize(this->K);
-			this->alphas.array() = this->alpha;
-			this->globalState.pLikelihood = Eigen::Matrix<Float, -1, 1>::Zero(numPDocs);
+			this->globalState.pLikelihood = Vector::Zero(numPDocs);
 			this->globalState.numDocsByPDoc = Eigen::ArrayXi::Zero(numPDocs);
 			this->globalState.numByTopicPDoc = Eigen::Matrix<WeightType, -1, -1>::Zero(this->K, numPDocs);
 			BaseClass::initGlobalState(initDocs);
@@ -175,15 +173,15 @@ namespace tomoto
 		struct Generator
 		{
 			std::uniform_int_distribution<uint64_t> psi;
-			std::uniform_int_distribution<Tid> theta;
+			Eigen::Rand::DiscreteGen<int32_t> theta;
 		};
 
 		Generator makeGeneratorForInit(const _DocType*) const
 		{
-			return Generator{ 
-				std::uniform_int_distribution<uint64_t>{0, numPDocs - 1},
-				std::uniform_int_distribution<Tid>{0, (Tid)(this->K - 1)}
-			};
+			Generator g;
+			g.psi = std::uniform_int_distribution<uint64_t>{ 0, numPDocs - 1 };
+			g.theta = Eigen::Rand::DiscreteGen<int32_t>{ this->alphas.data(), this->alphas.data() + this->alphas.size() };
+			return g;
 		}
 
 		template<bool _Infer>
@@ -256,17 +254,34 @@ namespace tomoto
 		DEFINE_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 0, numPDocs, lambda);
 		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 1, 0x00010001, numPDocs, lambda);
 
-		PTModel(size_t _K = 1, size_t _P = 100, Float _alpha = 1.0, Float _eta = 0.01, Float _lambda = 0.01,
-			size_t _rg = std::random_device{}())
-			: BaseClass(_K, _alpha, _eta, _rg), numPDocs(_P), lambda(_lambda)
+		GETTER(P, size_t, numPDocs);
+
+		PTModel(const PTArgs& args)
+			: BaseClass(args), numPDocs(args.p), lambda(args.lambda)
 		{
 		}
 
+		std::vector<Float> getTopicsByDoc(const _DocType& doc, bool normalize) const
+		{
+			std::vector<Float> ret(this->K);
+			Eigen::Map<Eigen::Array<Float, -1, 1>> m{ ret.data(), this->K };
+			m = this->alphas.array();
+			for (size_t i = 0; i < doc.words.size(); ++i)
+			{
+				if (doc.words[i] >= this->realV) continue;
+				typename std::conditional<_tw != TermWeight::one, float, int32_t>::type weight
+					= _tw != TermWeight::one ? doc.wordWeights[i] : 1;
+				ret[doc.Zs[i]] += weight;
+			}
+			if (normalize) m /= m.sum();
+			return ret;
+		}
+
 		void updateDocs()
 		{
 			for (auto& doc : this->docs)
 			{
-				doc.template update<>(this->getTopicDocPtr(doc.pseudoDoc), *static_cast<DerivedClass*>(this));
+				doc.template update<>(this->globalState.numByTopicPDoc.col(doc.pseudoDoc).data(), *static_cast<DerivedClass*>(this));
 			}
 		}
 	};

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

@@ -9,10 +9,19 @@ namespace tomoto
 		using BaseDocument = DocumentLDA<_tw>;
 		using DocumentLDA<_tw>::DocumentLDA;
 		std::vector<Float> y;
+
+		RawDoc::MiscType makeMisc(const ITopicModel* tm) const override
+		{
+			RawDoc::MiscType ret = DocumentLDA<_tw>::makeMisc(tm);
+			ret["y"] = y;
+			return ret;
+		}
 		DEFINE_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseDocument, 0, y);
 		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseDocument, 1, 0x00010001, y);
 	};
 
+	struct SLDAArgs;
+
 	class ISLDAModel : public ILDAModel
 	{
 	public:
@@ -23,12 +32,7 @@ namespace tomoto
 		};
 
 		using DefaultDocType = DocumentSLDA<TermWeight::one>;
-		static ISLDAModel* create(TermWeight _weight, size_t _K = 1, 
-			const std::vector<ISLDAModel::GLM>& vars = {},
-			Float alpha = 0.1, Float _eta = 0.01,
-			const std::vector<Float>& _mu = {}, const std::vector<Float>& _nuSq = {},
-			const std::vector<Float>& _glmParam = {},
-			size_t seed = std::random_device{}(),
+		static ISLDAModel* create(TermWeight _weight, const SLDAArgs& args,
 			bool scalarRng = false);
 
 		virtual size_t getF() const = 0;
@@ -36,4 +40,12 @@ namespace tomoto
 		virtual GLM getTypeOfVar(size_t f) const = 0;
 		virtual std::vector<Float> estimateVars(const DocumentBase* doc) const = 0;
 	};
+
+	struct SLDAArgs : public LDAArgs
+	{
+		std::vector<ISLDAModel::GLM> vars;
+		std::vector<Float> mu;
+		std::vector<Float> nuSq;
+		std::vector<Float> glmParam;
+	};
 }

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

@@ -2,16 +2,8 @@
 
 namespace tomoto
 {
-	/*template class SLDAModel<TermWeight::one>;
-	template class SLDAModel<TermWeight::idf>;
-	template class SLDAModel<TermWeight::pmi>;*/
-
-    ISLDAModel* ISLDAModel::create(TermWeight _weight, size_t _K, const std::vector<ISLDAModel::GLM>& vars,
-		Float _alpha, Float _eta, 
-		const std::vector<Float>& _mu, const std::vector<Float>& _nuSq,
-		const std::vector<Float>& _glmParam,
-		size_t seed, bool scalarRng)
+    ISLDAModel* ISLDAModel::create(TermWeight _weight, const SLDAArgs& args, bool scalarRng)
 	{
-		TMT_SWITCH_TW(_weight, scalarRng, SLDAModel, _K, vars, _alpha, _eta, _mu, _nuSq, _glmParam, seed);
+		TMT_SWITCH_TW(_weight, scalarRng, SLDAModel, args);
 	}
 }

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

@@ -16,22 +16,24 @@ namespace tomoto
 		template<typename _WeightType>
 		struct GLMFunctor
 		{
-			Eigen::Matrix<Float, -1, 1> regressionCoef; // Dim : (K)
+			Vector regressionCoef; // Dim : (K)
 
-			GLMFunctor(size_t K = 0, Float mu = 0) : regressionCoef(Eigen::Matrix<Float, -1, 1>::Constant(K, mu))
+			GLMFunctor(size_t K = 0, Float mu = 0) : regressionCoef(Vector::Constant(K, mu))
 			{
 			}
 
 			virtual ISLDAModel::GLM getType() const = 0;
 
+			virtual std::unique_ptr<GLMFunctor> copy() const = 0;
+
 			virtual void updateZLL(
-				Eigen::Matrix<Float, -1, 1>& zLikelihood,
+				Vector& zLikelihood,
 				Float y, const Eigen::Matrix<_WeightType, -1, 1>& numByTopic, size_t docId, Float docSize) const = 0;
 
 			virtual void optimizeCoef(
-				const Eigen::Matrix<Float, -1, -1>& normZ,
+				const Matrix& normZ,
 				Float mu, Float nuSq,
-				Eigen::Block<Eigen::Matrix<Float, -1, -1>, -1, 1, true> ys
+				Eigen::Block<Matrix, -1, 1, true> ys
 			) = 0;
 
 			virtual double getLL(Float y, const Eigen::Matrix<_WeightType, -1, 1>& numByTopic,
@@ -69,8 +71,13 @@ namespace tomoto
 
 			ISLDAModel::GLM getType() const override { return ISLDAModel::GLM::linear; }
 
+			std::unique_ptr<GLMFunctor<_WeightType>> copy() const override
+			{
+				return std::make_unique<LinearFunctor>(*this);
+			}
+
 			void updateZLL(
-				Eigen::Matrix<Float, -1, 1>& zLikelihood,
+				Vector& zLikelihood,
 				Float y, const Eigen::Matrix<_WeightType, -1, 1>& numByTopic, size_t docId, Float docSize) const override
 			{
 				Float yErr = y -
@@ -81,14 +88,14 @@ namespace tomoto
 			}
 
 			void optimizeCoef(
-				const Eigen::Matrix<Float, -1, -1>& normZ,
+				const Matrix& normZ,
 				Float mu, Float nuSq,
-				Eigen::Block<Eigen::Matrix<Float, -1, -1>, -1, 1, true> ys
+				Eigen::Block<Matrix, -1, 1, true> ys
 			) override
 			{
-				Eigen::Matrix<Float, -1, -1> selectedNormZ = normZ.array().rowwise() * (!ys.array().transpose().isNaN()).template cast<Float>();
-				Eigen::Matrix<Float, -1, -1> normZZT = selectedNormZ * selectedNormZ.transpose();
-				normZZT += Eigen::Matrix<Float, -1, -1>::Identity(normZZT.cols(), normZZT.cols()) / nuSq;
+				Matrix selectedNormZ = normZ.array().rowwise() * (!ys.array().transpose().isNaN()).template cast<Float>();
+				Matrix normZZT = selectedNormZ * selectedNormZ.transpose();
+				normZZT += Matrix::Identity(normZZT.cols(), normZZT.cols()) / nuSq;
 				this->regressionCoef = normZZT.colPivHouseholderQr().solve(selectedNormZ * ys.array().isNaN().select(0, ys).matrix());
 			}
 
@@ -113,17 +120,22 @@ namespace tomoto
 		struct BinaryLogisticFunctor : public GLMFunctor<_WeightType>
 		{
 			Float b = 1;
-			Eigen::Matrix<Float, -1, 1> omega;
+			Vector omega;
 
 			BinaryLogisticFunctor(size_t K = 0, Float mu = 0, Float _b = 1, size_t numDocs = 0)
-				: GLMFunctor<_WeightType>(K, mu), b(_b), omega{ Eigen::Matrix<Float, -1, 1>::Ones(numDocs) }
+				: GLMFunctor<_WeightType>(K, mu), b(_b), omega{ Vector::Ones(numDocs) }
 			{
 			}
 
 			ISLDAModel::GLM getType() const override { return ISLDAModel::GLM::binary_logistic; }
 
+			std::unique_ptr<GLMFunctor<_WeightType>> copy() const override
+			{
+				return std::make_unique<BinaryLogisticFunctor>(*this);
+			}
+
 			void updateZLL(
-				Eigen::Matrix<Float, -1, 1>& zLikelihood,
+				Vector& zLikelihood,
 				Float y, const Eigen::Matrix<_WeightType, -1, 1>& numByTopic, size_t docId, Float docSize) const override
 			{
 				Float yErr = b * (y - 0.5f) -
@@ -134,18 +146,18 @@ namespace tomoto
 			}
 
 			void optimizeCoef(
-				const Eigen::Matrix<Float, -1, -1>& normZ,
+				const Matrix& normZ,
 				Float mu, Float nuSq,
-				Eigen::Block<Eigen::Matrix<Float, -1, -1>, -1, 1, true> ys
+				Eigen::Block<Matrix, -1, 1, true> ys
 			) override
 			{
-				Eigen::Matrix<Float, -1, -1> selectedNormZ = normZ.array().rowwise() * (!ys.array().transpose().isNaN()).template cast<Float>();
-				Eigen::Matrix<Float, -1, -1> normZZT = selectedNormZ * Eigen::DiagonalMatrix<Float, -1>{ omega } * selectedNormZ.transpose();
-				normZZT += Eigen::Matrix<Float, -1, -1>::Identity(normZZT.cols(), normZZT.cols()) / nuSq;
+				Matrix selectedNormZ = normZ.array().rowwise() * (!ys.array().transpose().isNaN()).template cast<Float>();
+				Matrix normZZT = selectedNormZ * Eigen::DiagonalMatrix<Float, -1>{ omega } * selectedNormZ.transpose();
+				normZZT += Matrix::Identity(normZZT.cols(), normZZT.cols()) / nuSq;
 
 				this->regressionCoef = normZZT
 					.colPivHouseholderQr().solve(selectedNormZ * ys.array().isNaN().select(0, b * (ys.array() - 0.5f)).matrix()
-						+ Eigen::Matrix<Float, -1, 1>::Constant(selectedNormZ.rows(), mu / nuSq));
+						+ Vector::Constant(selectedNormZ.rows(), mu / nuSq));
 
 				RandGen rng;
 				for (size_t i = 0; i < (size_t)omega.size(); ++i)
@@ -173,8 +185,20 @@ namespace tomoto
 
 			DEFINE_SERIALIZER_AFTER_BASE(GLMFunctor<_WeightType>, b, omega);
 		};
+
+		struct CopyGLMFunctor
+		{
+			template<typename Wt>
+			std::vector<std::unique_ptr<GLMFunctor<Wt>>> operator()(const std::vector<std::unique_ptr<GLMFunctor<Wt>>>& o)
+			{
+				std::vector<std::unique_ptr<GLMFunctor<Wt>>> ret;
+				for (auto& p : o) ret.emplace_back(p->copy());
+				return ret;
+			}
+		};
 	}
 
+
 	template<TermWeight _tw, typename _RandGen,
 		size_t _Flags = flags::partitioned_multisampling,
 		typename _Interface = ISLDAModel,
@@ -198,12 +222,12 @@ namespace tomoto
 		std::vector<ISLDAModel::GLM> varTypes;
 		std::vector<Float> glmParam;
 
-		Eigen::Matrix<Float, -1, 1> mu; // Mean of regression coefficients, Dim : (F)
-		Eigen::Matrix<Float, -1, 1> nuSq; // Variance of regression coefficients, Dim : (F)
+		Vector mu; // Mean of regression coefficients, Dim : (F)
+		Vector nuSq; // Variance of regression coefficients, Dim : (F)
 
-		std::vector<std::unique_ptr<detail::GLMFunctor<WeightType>>> responseVars;
-		Eigen::Matrix<Float, -1, -1> normZ; // topic proportions for all docs, Dim : (K, D)
-		Eigen::Matrix<Float, -1, -1> Ys; // response variables, Dim : (D, F)
+		DelegateCopy<std::vector<std::unique_ptr<detail::GLMFunctor<WeightType>>>, detail::CopyGLMFunctor> responseVars;
+		Matrix normZ; // topic proportions for all docs, Dim : (K, D)
+		Matrix Ys; // response variables, Dim : (D, F)
 
 		template<bool _asymEta>
 		Float* getZLikelihoods(_ModelState& ld, const _DocType& doc, size_t docId, size_t vid) const
@@ -299,11 +323,11 @@ namespace tomoto
 					switch (varTypes[f])
 					{
 					case ISLDAModel::GLM::linear:
-						v = make_unique<detail::LinearFunctor<WeightType>>(this->K, mu[f], 
+						v = std::make_unique<detail::LinearFunctor<WeightType>>(this->K, mu[f],
 							f < glmParam.size() ? glmParam[f] : 1.f);
 						break;
 					case ISLDAModel::GLM::binary_logistic:
-						v = make_unique<detail::BinaryLogisticFunctor<WeightType>>(this->K, mu[f],
+						v = std::make_unique<detail::BinaryLogisticFunctor<WeightType>>(this->K, mu[f],
 							f < glmParam.size() ? glmParam[f] : 1.f, this->docs.size());
 						break;
 					}
@@ -322,22 +346,48 @@ namespace tomoto
 		DEFINE_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 0, F, responseVars, mu, nuSq);
 		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 1, 0x00010001, F, responseVars, mu, nuSq);
 
-		SLDAModel(size_t _K = 1, const std::vector<ISLDAModel::GLM>& vars = {}, 
-			Float _alpha = 0.1, Float _eta = 0.01, 
-			const std::vector<Float>& _mu = {}, const std::vector<Float>& _nuSq = {},
-			const std::vector<Float>& _glmParam = {},
-			size_t _rg = std::random_device{}())
-			: BaseClass(_K, _alpha, _eta, _rg), F(vars.size()), varTypes(vars), 
-			glmParam(_glmParam)
+		SLDAModel(const SLDAArgs& args)
+			: BaseClass(args), F(args.vars.size()), varTypes(args.vars),
+			glmParam(args.glmParam)
 		{
 			for (auto t : varTypes)
 			{
-				if (t != ISLDAModel::GLM::linear && t != ISLDAModel::GLM::binary_logistic) THROW_ERROR_WITH_INFO(std::runtime_error, "unknown var GLM type in 'vars'");
+				if ((size_t)t > (size_t)ISLDAModel::GLM::binary_logistic) THROW_ERROR_WITH_INFO(exc::InvalidArgument, "unknown var GLM type in `vars`");
+			}
+
+			if (args.mu.size() == 0)
+			{
+				mu = Vector::Zero(F);
+			}
+			else if (args.mu.size() == 1)
+			{
+				mu = Vector::Constant(F, args.mu[0]);
+			}
+			else if (args.mu.size() == F)
+			{
+				mu = Eigen::Map<const Vector>(args.mu.data(), args.mu.size());
+			}
+			else
+			{
+				THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong mu value (len = %zd)", args.mu.size()));
+			}
+
+			if (args.nuSq.size() == 0)
+			{
+				nuSq = Vector::Ones(F);
+			}
+			else if (args.mu.size() == 1)
+			{
+				nuSq = Vector::Constant(F, args.nuSq[0]);
+			}
+			else if (args.mu.size() == F)
+			{
+				nuSq = Eigen::Map<const Vector>(args.nuSq.data(), args.nuSq.size());
+			}
+			else
+			{
+				THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong nuSq value (len = %zd)", args.nuSq.size()));
 			}
-			mu = decltype(mu)::Zero(F);
-			std::copy(_mu.begin(), _mu.end(), mu.data());
-			nuSq = decltype(nuSq)::Ones(F);
-			std::copy(_nuSq.begin(), _nuSq.end(), nuSq.data());
 		}
 
 		std::vector<Float> getRegressionCoef(size_t f) const override
@@ -385,7 +435,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<Float>>("y")));
+			return std::make_unique<_DocType>(as_mutable(this)->template _updateDoc<true>(doc, rawDoc.template getMiscDefault<std::vector<Float>>("y")));
 		}
 
 		size_t addDoc(const RawDoc& rawDoc) override
@@ -397,7 +447,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>(as_mutable(this)->template _updateDoc<true>(doc, rawDoc.template getMiscDefault<std::vector<Float>>("y")));
+			return std::make_unique<_DocType>(as_mutable(this)->template _updateDoc<true>(doc, rawDoc.template getMiscDefault<std::vector<Float>>("y")));
 		}
 
 		std::vector<Float> estimateVars(const DocumentBase* doc) const override
@@ -424,10 +474,10 @@ namespace tomoto
 			switch ((ISLDAModel::GLM)(t - 1))
 			{
 			case ISLDAModel::GLM::linear:
-				p = make_unique<LinearFunctor<_WeightType>>();
+				p = std::make_unique<LinearFunctor<_WeightType>>();
 				break;
 			case ISLDAModel::GLM::binary_logistic:
-				p = make_unique<BinaryLogisticFunctor<_WeightType>>();
+				p = std::make_unique<BinaryLogisticFunctor<_WeightType>>();
 				break;
 			default:
 				throw std::ios_base::failure(text::format("wrong GLMFunctor type id %d", (t - 1)));