tomoto 0.1.4 → 0.2.0

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

@@ -161,12 +161,19 @@ namespace tomoto
 		}
 	};
 
+	struct LDAArgs
+	{
+		size_t k = 1;
+		std::vector<Float> alpha = { 0.1 };
+		Float eta = 0.01;
+		size_t seed = std::random_device{}();
+	};
+
     class ILDAModel : public ITopicModel
 	{
 	public:
 		using DefaultDocType = DocumentLDA<TermWeight::one>;
-		static ILDAModel* create(TermWeight _weight, size_t _K = 1, 
-			Float _alpha = 0.1, Float _eta = 0.01, size_t seed = std::random_device{}(),
+		static ILDAModel* create(TermWeight _weight, const LDAArgs& args,
 			bool scalarRng = false);
 
 		virtual TermWeight getTermWeight() const = 0;

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

@@ -85,7 +85,7 @@ namespace tomoto
 		static constexpr static constexpr char TMID[] = "LDA\0";
 
 		Float alpha;
-		Eigen::Matrix<Float, -1, 1> alphas;
+		Vector alphas;
 		Float eta;
 		Tid K;
 		size_t optimInterval = 50;
@@ -93,7 +93,7 @@ namespace tomoto
 		template<typename _List>
 		static Float calcDigammaSum(_List list, size_t len, Float alpha)
 		{
-			auto listExpr = Eigen::Matrix<Float, -1, 1>::NullaryExpr(len, list);
+			auto listExpr = Vector::NullaryExpr(len, list);
 			auto dAlpha = math::digammaT(alpha);
 			return (math::digammaApprox(listExpr.array() + alpha) - dAlpha).sum();
 		}
@@ -265,11 +265,11 @@ namespace tomoto
 		void initGlobalState(bool initDocs)
 		{
 			const size_t V = this->realV;
-			this->globalState.zLikelihood = Eigen::Matrix<Float, -1, 1>::Zero(K);
+			this->globalState.zLikelihood = Vector::Zero(K);
 			if (initDocs)
 			{
-				this->globalState.numByTopic = Eigen::Matrix<Float, -1, 1>::Zero(K);
-				this->globalState.numByTopicWord = Eigen::Matrix<Float, -1, -1>::Zero(K, V);
+				this->globalState.numByTopic = Vector::Zero(K);
+				this->globalState.numByTopicWord = Matrix::Zero(K, V);
 			}
 		}
 
@@ -335,7 +335,7 @@ namespace tomoto
 		LDACVB0Model(size_t _K = 1, Float _alpha = 0.1, Float _eta = 0.01, size_t _rg = std::random_device{}())
 			: BaseClass(_rg), K(_K), alpha(_alpha), eta(_eta)
 		{ 
-			alphas = Eigen::Matrix<Float, -1, 1>::Constant(K, alpha);
+			alphas = Vector::Constant(K, alpha);
 		}
 		GETTER(K, size_t, K);
 		GETTER(Alpha, Float, alpha);
@@ -355,7 +355,7 @@ namespace tomoto
 
 		std::unique_ptr<DocumentBase> makeDoc(const std::vector<std::string>& words) const override
 		{
-			return make_unique<_DocType>(as_mutable(this)->template _makeDoc<true>(words));
+			return std::make_unique<_DocType>(as_mutable(this)->template _makeDoc<true>(words));
 		}
 
 		void updateDocs()
@@ -403,7 +403,7 @@ namespace tomoto
 			return ret;
 		}
 
-		std::vector<Float> _getWidsByTopic(Tid tid) const
+		std::vector<Float> _getWidsByTopic(Tid tid, bool normalize = true) const
 		{
 			assert(tid < K);
 			const size_t V = this->realV;

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

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

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

@@ -56,7 +56,7 @@ namespace tomoto
 	{
 		using WeightType = typename std::conditional<_tw == TermWeight::one, int32_t, float>::type;
 
-		Eigen::Matrix<Float, -1, 1> zLikelihood;
+		Vector zLikelihood;
 		Eigen::Matrix<WeightType, -1, 1> numByTopic; // Dim: (Topic, 1)
 		//Eigen::Matrix<WeightType, -1, -1> numByTopicWord; // Dim: (Topic, Vocabs)
 		ShareableMatrix<WeightType, -1, -1> numByTopicWord; // Dim: (Topic, Vocabs)
@@ -179,10 +179,10 @@ namespace tomoto
 		std::vector<Float> sharedWordWeights;
 		Tid K;
 		Float alpha, eta;
-		Eigen::Matrix<Float, -1, 1> alphas;
+		Vector alphas;
 		std::unordered_map<std::string, std::vector<Float>> etaByWord;
-		Eigen::Matrix<Float, -1, -1> etaByTopicWord; // (K, V)
-		Eigen::Matrix<Float, -1, 1> etaSumByTopic; // (K, )
+		Matrix etaByTopicWord; // (K, V)
+		Vector etaSumByTopic; // (K, )
 		uint32_t optimInterval = 10, burnIn = 0;
 		Eigen::Matrix<WeightType, -1, -1> numByTopicDoc;
 		
@@ -197,7 +197,7 @@ namespace tomoto
 		template<typename _List>
 		static Float calcDigammaSum(ThreadPool* pool, _List list, size_t len, Float alpha)
 		{
-			auto listExpr = Eigen::Matrix<Float, -1, 1>::NullaryExpr(len, list);
+			auto listExpr = Vector::NullaryExpr(len, list);
 			auto dAlpha = math::digammaT(alpha);
 
 			size_t suggested = (len + 127) / 128;
@@ -507,7 +507,7 @@ namespace tomoto
 					static_cast<DerivedClass*>(this)->optimizeParameters(pool, localData, rgs);
 				}
 			}
-			catch (const exception::TrainingError&)
+			catch (const exc::TrainingError&)
 			{
 				for (auto& r : res) if(r.valid()) r.get();
 				throw;
@@ -663,6 +663,22 @@ namespace tomoto
 					makeTransformIter(this->docs.end(), txWeights));
 			}
 		}
+
+		void updateForCopy()
+		{
+			BaseClass::updateForCopy();
+			size_t offset = 0;
+			for (auto& doc : this->docs)
+			{
+				size_t size = doc.Zs.size();
+				doc.Zs = tvector<Tid>{ sharedZs.data() + offset, size };
+				if (_tw != TermWeight::one)
+				{
+					doc.wordWeights = tvector<Float>{ sharedWordWeights.data() + offset, size };
+				}
+				offset += size;
+			}
+		}
 		
 		WeightType* getTopicDocPtr(size_t docId) const
 		{
@@ -670,11 +686,14 @@ namespace tomoto
 			return (WeightType*)numByTopicDoc.col(docId).data();
 		}
 
+		/*
+		* called only when initializing a new doc, not when loading from saved model
+		*/
 		void prepareDoc(_DocType& doc, size_t docId, size_t wordSize) const
 		{
 			sortAndWriteOrder(doc.words, doc.wOrder);
 			doc.numByTopic.init(getTopicDocPtr(docId), K, 1);
-			doc.Zs = tvector<Tid>(wordSize);
+			doc.Zs = tvector<Tid>(wordSize, non_topic_id);
 			if(_tw != TermWeight::one) doc.wordWeights.resize(wordSize);
 		}
 
@@ -688,7 +707,7 @@ namespace tomoto
 			{
 				auto id = this->dict.toWid(it.first);
 				if (id == (Vid)-1 || id >= this->realV) continue;
-				etaByTopicWord.col(id) = Eigen::Map<Eigen::Matrix<Float, -1, 1>>{ it.second.data(), (Eigen::Index)it.second.size() };
+				etaByTopicWord.col(id) = Eigen::Map<Vector>{ it.second.data(), (Eigen::Index)it.second.size() };
 			}
 			etaSumByTopic = etaByTopicWord.rowwise().sum();
 		}
@@ -696,7 +715,7 @@ namespace tomoto
 		void initGlobalState(bool initDocs)
 		{
 			const size_t V = this->realV;
-			this->globalState.zLikelihood = Eigen::Matrix<Float, -1, 1>::Zero(K);
+			this->globalState.zLikelihood = Vector::Zero(K);
 			if (initDocs)
 			{
 				this->globalState.numByTopic = Eigen::Matrix<WeightType, -1, 1>::Zero(K);
@@ -708,12 +727,14 @@ namespace tomoto
 
 		struct Generator
 		{
-			std::uniform_int_distribution<Tid> theta;
+			Eigen::Rand::DiscreteGen<int32_t> theta;
 		};
 
 		Generator makeGeneratorForInit(const _DocType*) const
 		{
-			return Generator{ std::uniform_int_distribution<Tid>{0, (Tid)(K - 1)} };
+			Generator g;
+			g.theta = Eigen::Rand::DiscreteGen<int32_t>{ alphas.data(), alphas.data() + alphas.size() };
+			return g;
 		}
 
 		template<bool _Infer>
@@ -780,12 +801,13 @@ namespace tomoto
 			return cnt;
 		}
 
-		std::vector<Float> _getWidsByTopic(size_t tid) const
+		std::vector<Float> _getWidsByTopic(size_t tid, bool normalize = true) const
 		{
 			assert(tid < this->globalState.numByTopic.rows());
 			const size_t V = this->realV;
 			std::vector<Float> ret(V);
 			Float sum = this->globalState.numByTopic[tid] + V * eta;
+			if (!normalize) sum = 1;
 			auto r = this->globalState.numByTopicWord.row(tid);
 			for (size_t v = 0; v < V; ++v)
 			{
@@ -794,7 +816,7 @@ namespace tomoto
 			return ret;
 		}
 
-		template<bool _Together, ParallelScheme _ps, typename _Iter>
+		template<bool together, ParallelScheme _ps, typename _Iter>
 		std::vector<double> _infer(_Iter docFirst, _Iter docLast, size_t maxIter, Float tolerance, size_t numWorkers) const
 		{
 			decltype(static_cast<const DerivedClass*>(this)->makeGeneratorForInit(nullptr)) generator;
@@ -803,7 +825,7 @@ namespace tomoto
 				generator = static_cast<const DerivedClass*>(this)->makeGeneratorForInit(nullptr);
 			}
 
-			if (_Together)
+			if (together)
 			{
 				numWorkers = std::min(numWorkers, this->maxThreads[(size_t)_ps]);
 				ThreadPool pool{ numWorkers };
@@ -913,13 +935,26 @@ namespace tomoto
 		DEFINE_TAGGED_SERIALIZER_WITH_VERSION(1, 0x00010001, vocabWeights, alpha, alphas, eta, K, etaByWord,
 			burnIn, optimInterval);
 
-		LDAModel(size_t _K = 1, Float _alpha = 0.1, Float _eta = 0.01, size_t _rg = std::random_device{}())
-			: BaseClass(_rg), K(_K), alpha(_alpha), eta(_eta)
-		{ 
-			if (_K == 0 || _K >= 0x80000000) THROW_ERROR_WITH_INFO(std::runtime_error, text::format("wrong K value (K = %zd)", _K));
-			if (_alpha <= 0) THROW_ERROR_WITH_INFO(std::runtime_error, text::format("wrong alpha value (alpha = %f)", _alpha));
-			if (_eta <= 0) THROW_ERROR_WITH_INFO(std::runtime_error, text::format("wrong eta value (eta = %f)", _eta));
-			alphas = Eigen::Matrix<Float, -1, 1>::Constant(K, alpha);
+		LDAModel(const LDAArgs& args, bool checkAlpha = true)
+			: BaseClass(args.seed), K(args.k), alpha(args.alpha[0]), eta(args.eta)
+		{
+			if (K == 0 || K >= 0x80000000) THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong K value (K = %zd)", K));
+
+			if (args.alpha.size() == 1)
+			{
+				alphas = Vector::Constant(K, alpha);
+			}
+			else if (args.alpha.size() == args.k)
+			{
+				alphas = Eigen::Map<const Vector>(args.alpha.data(), args.alpha.size());
+			}
+			else if (checkAlpha)
+			{
+				THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong alpha value (len = %zd)", args.alpha.size()));
+			}
+
+			if ((alphas.array() <= 0).any()) THROW_ERROR_WITH_INFO(exc::InvalidArgument, "wrong alpha value");
+			if (eta <= 0) THROW_ERROR_WITH_INFO(exc::InvalidArgument, text::format("wrong eta value (eta = %f)", eta));
 		}
 
 		GETTER(K, size_t, K);
@@ -952,7 +987,7 @@ namespace tomoto
 
 		std::unique_ptr<DocumentBase> makeDoc(const RawDoc& rawDoc, const RawDocTokenizer::Factory& tokenizer) const override
 		{
-			return make_unique<_DocType>(as_mutable(this)->template _makeFromRawDoc<true>(rawDoc, tokenizer));
+			return std::make_unique<_DocType>(as_mutable(this)->template _makeFromRawDoc<true>(rawDoc, tokenizer));
 		}
 
 		size_t addDoc(const RawDoc& rawDoc) override
@@ -962,15 +997,15 @@ namespace tomoto
 
 		std::unique_ptr<DocumentBase> makeDoc(const RawDoc& rawDoc) const override
 		{
-			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() != K) THROW_ERROR_WITH_INFO(exception::InvalidArgument, "priors.size() must be equal to K.");
+			if (priors.size() != K) 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);
 			etaByWord.emplace(word, priors);
@@ -1069,11 +1104,18 @@ namespace tomoto
 			return static_cast<const DerivedClass*>(this)->_getTopicsCount();
 		}
 
-		std::vector<Float> getTopicsByDoc(const _DocType& doc) const
+		std::vector<Float> getTopicsByDoc(const _DocType& doc, bool normalize) const
 		{
 			std::vector<Float> ret(K);
-			Eigen::Map<Eigen::Matrix<Float, -1, 1>> { ret.data(), K }.array() = 
-				(doc.numByTopic.array().template cast<Float>() + alphas.array()) / (doc.getSumWordWeight() + alphas.sum());
+			Eigen::Map<Eigen::Array<Float, -1, 1>> m{ ret.data(), K };
+			if (normalize)
+			{
+				m = (doc.numByTopic.array().template cast<Float>() + alphas.array()) / (doc.getSumWordWeight() + alphas.sum());
+			}
+			else
+			{
+				m = doc.numByTopic.array().template cast<Float>() + alphas.array();
+			}
 			return ret;
 		}
 

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

@@ -19,8 +19,7 @@ namespace tomoto
 	{
 	public:
 		using DefaultDocType = DocumentLLDA<TermWeight::one>;
-		static ILLDAModel* create(TermWeight _weight, size_t _K = 1, 
-			Float alpha = 0.1, Float eta = 0.01, size_t seed = std::random_device{}(),
+		static ILLDAModel* create(TermWeight _weight, const LDAArgs& args,
 			bool scalarRng = false);
 
 		virtual const Dictionary& getTopicLabelDict() const = 0;

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

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

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

@@ -71,13 +71,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
 		{
-			std::discrete_distribution<> theta{ doc->labelMask.data(), doc->labelMask.data() + this->K };
-			return Generator{ theta };
+			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>
@@ -88,7 +91,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
@@ -102,8 +105,8 @@ namespace tomoto
 		DEFINE_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 0, topicLabelDict);
 		DEFINE_TAGGED_SERIALIZER_AFTER_BASE_WITH_VERSION(BaseClass, 1, 0x00010001, topicLabelDict);
 
-		LLDAModel(size_t _K = 1, Float _alpha = 1.0, Float _eta = 0.01, size_t _rg = std::random_device{}())
-			: BaseClass(_K, _alpha, _eta, _rg)
+		LLDAModel(const LDAArgs& args)
+			: BaseClass(args)
 		{
 		}
 
@@ -153,7 +156,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
@@ -165,16 +168,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;
 		}
 

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

@@ -28,13 +28,22 @@ namespace tomoto
 		template<typename _TopicModel> void update(WeightType* ptr, const _TopicModel& mdl);
 	};
 
+	struct MGLDAArgs : public LDAArgs
+	{
+		size_t kL = 1;
+		size_t t = 3;
+		std::vector<Float> alphaL = { 0.1 };
+		Float alphaMG = 0.1;
+		Float alphaML = 0.1;
+		Float etaL = 0.01;
+		Float gamma = 0.1;
+	};
+
 	class IMGLDAModel : public ILDAModel
 	{
 	public:
 		using DefaultDocType = DocumentMGLDA<TermWeight::one>;
-		static IMGLDAModel* create(TermWeight _weight, 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 seed = std::random_device{}(),
+		static IMGLDAModel* create(TermWeight _weight, const MGLDAArgs& args,
 			bool scalarRng = false);
 
 		virtual size_t getKL() const = 0;