tomoto 0.1.3 → 0.1.4

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

@@ -121,6 +121,7 @@ namespace tomoto
 	};
 
 	enum class ParallelScheme { default_, none, copy_merge, partition, size };
+	enum class GlobalSampler { train, freeze_topics, inference, size };
 
 	inline const char* toString(ParallelScheme ps)
 	{
@@ -236,7 +237,7 @@ namespace tomoto
 		virtual const std::vector<uint64_t>& getVocabCf() const = 0;
 		virtual const std::vector<uint64_t>& getVocabDf() const = 0;
 
-		virtual int train(size_t iteration, size_t numWorkers, ParallelScheme ps = ParallelScheme::default_) = 0;
+		virtual int train(size_t iteration, size_t numWorkers, ParallelScheme ps = ParallelScheme::default_, bool freeze_topics = false) = 0;
 		virtual size_t getGlobalStep() const = 0;
 		virtual void prepare(bool initDocs = true, size_t minWordCnt = 0, size_t minWordDf = 0, size_t removeTopN = 0) = 0;
 		
@@ -588,7 +589,7 @@ namespace tomoto
 			return ps;
 		}
 
-		int train(size_t iteration, size_t numWorkers, ParallelScheme ps) override
+		int train(size_t iteration, size_t numWorkers, ParallelScheme ps, bool freeze_topics = false) override
 		{
 			if (!numWorkers) numWorkers = std::thread::hardware_concurrency();
 			ps = getRealScheme(ps);
@@ -606,16 +607,20 @@ namespace tomoto
 				localRG.emplace_back(rg());
 			}
 
-			for (size_t i = 0; i < numWorkers; ++i)
+			if (ps == ParallelScheme::copy_merge)
 			{
-				if(ps == ParallelScheme::copy_merge) localData.emplace_back(static_cast<_Derived*>(this)->globalState);
+				for (size_t i = 0; i < numWorkers; ++i)
+				{
+					localData.emplace_back(static_cast<_Derived*>(this)->globalState);
+				}
 			}
-
-			if (ps == ParallelScheme::partition)
+			else if (ps == ParallelScheme::partition)
 			{
 				localData.resize(numWorkers);
-				static_cast<_Derived*>(this)->updatePartition(*cachedPool, globalState, localData.data(), docs.begin(), docs.end(), 
-					static_cast<_Derived*>(this)->eddTrain);
+				static_cast<_Derived*>(this)->updatePartition(
+					*cachedPool, globalState, localData.data(), docs.begin(), docs.end(), 
+					static_cast<_Derived*>(this)->eddTrain
+				);
 			}
 
 			auto state = ps == ParallelScheme::none ? &globalState : localData.data();
@@ -629,15 +634,15 @@ namespace tomoto
 						{
 						case ParallelScheme::none:
 							static_cast<_Derived*>(this)->template trainOne<ParallelScheme::none>(
-								*cachedPool, state, localRG.data());
+								*cachedPool, state, localRG.data(), freeze_topics);
 							break;
 						case ParallelScheme::copy_merge:
 							static_cast<_Derived*>(this)->template trainOne<ParallelScheme::copy_merge>(
-								*cachedPool, state, localRG.data());
+								*cachedPool, state, localRG.data(), freeze_topics);
 							break;
 						case ParallelScheme::partition:
 							static_cast<_Derived*>(this)->template trainOne<ParallelScheme::partition>(
-								*cachedPool, state, localRG.data());
+								*cachedPool, state, localRG.data(), freeze_topics);
 							break;
 						}
 						break;

data/vendor/tomotopy/src/Utils/MultiNormalDistribution.hpp

@@ -51,8 +51,9 @@ namespace tomoto
 					}
 					if (len > 1) newDist.cov /= len - 1;
 				}
-				newDist.l = newDist.cov.llt().matrixL();
-				newDist.logDet = newDist.l.diagonal().array().log().sum();
+				Eigen::MatrixXd l = newDist.cov.template cast<double>().llt().matrixL();
+				newDist.l = l.template cast<float>();
+				newDist.logDet = l.diagonal().array().log().sum();
 				return newDist;
 			}
 

data/vendor/tomotopy/src/Utils/Trie.hpp

@@ -26,10 +26,31 @@ namespace tomoto
 		}
 	};
 
+	template<class _Map, class _Node>
+	class TrieIterator : public _Map::const_iterator
+	{
+		using Base = typename _Map::const_iterator;
+		using Key = typename _Map::key_type;
+		const _Node* base = nullptr;
+	public:
+
+		TrieIterator(const Base& it, const _Node* _base)
+			: Base(it), base(_base)
+		{
+		}
+
+		std::pair<const Key, const _Node*> operator*() const
+		{
+			auto p = Base::operator*();
+			return std::make_pair(p.first, base + p.second);
+		}
+	};
+
 	template<class _Key, class _Value, class _KeyStore = ConstAccess<std::map<_Key, int32_t>>, class _Trie = void>
 	struct Trie
 	{
 		using Node = typename std::conditional<std::is_same<_Trie, void>::value, Trie, _Trie>::type;
+		using iterator = TrieIterator<_KeyStore, Node>;
 		_KeyStore next = {};
 		int32_t fail = 0;
 		_Value val = {};
@@ -47,13 +68,23 @@ namespace tomoto
 			return fail ? (Node*)this + fail : nullptr;
 		}
 
+		iterator begin() const
+		{
+			return { next.begin(), (const Node*)this };
+		}
+
+		iterator end() const
+		{
+			return { next.end(), (const Node*)this };
+		}
+
 		template<typename _TyIter, typename _FnAlloc>
-		void build(_TyIter first, _TyIter last, const _Value& _val, _FnAlloc&& alloc)
+		Node* build(_TyIter first, _TyIter last, const _Value& _val, _FnAlloc&& alloc)
 		{
 			if (first == last)
 			{
 				if (!val) val = _val;
-				return;
+				return (Node*)this;
 			}
 
 			auto v = *first;
@@ -61,13 +92,13 @@ namespace tomoto
 			{
 				next[v] = alloc() - this;
 			}
-			getNext(v)->build(++first, last, _val, alloc);
+			return getNext(v)->build(++first, last, _val, alloc);
 		}
 
 		template<typename _TyIter>
 		Node* findNode(_TyIter begin, _TyIter end)
 		{
-			if (begin == end) return this;
+			if (begin == end) return (Node*)this;
 			auto n = getNext(*begin);
 			if (n) return n->findNode(++begin, end);
 			return nullptr;
@@ -173,21 +204,21 @@ namespace tomoto
 		int32_t parent = 0;
 
 		template<typename _TyIter, typename _FnAlloc>
-		void build(_TyIter first, _TyIter last, const _Value& _val, _FnAlloc&& alloc)
+		TrieEx* build(_TyIter first, _TyIter last, const _Value& _val, _FnAlloc&& alloc)
 		{
 			if (first == last)
 			{
 				if (!this->val) this->val = _val;
-				return;
+				return this;
 			}
 
 			auto v = *first;
-			if (!getNext(v))
+			if (!this->getNext(v))
 			{
 				this->next[v] = alloc() - this;
 				this->getNext(v)->parent = -this->next[v];
 			}
-			this->getNext(v)->build(++first, last, _val, alloc);
+			return this->getNext(v)->build(++first, last, _val, alloc);
 		}
 
 		template<typename _FnAlloc>

data/vendor/tomotopy/src/Utils/TruncMultiNormal.hpp

@@ -14,57 +14,55 @@ namespace tomoto
 			const Eigen::Matrix<_Ty, -1, 1>& lowerBound,
 			const Eigen::Matrix<_Ty, -1, 1>& upperBound,
 			_Rng& rng,
-			size_t iteration)
+			size_t burnIn
+		)
 		{
-			constexpr _Ty epsilon = 1e-6;
 			const size_t K = ret.size();
-			Eigen::Matrix<_Ty, -1, 1> bias = Eigen::Matrix<_Ty, -1, 1>::Zero(K), lowers, uppers;
-			auto& l = multiNormal.getCovL();
-			ret.setZero();
-
-			std::vector<size_t> ks(K);
-			std::iota(ks.begin(), ks.end(), 0);
-			for (size_t i = 0; i < iteration; ++i)
+			Eigen::Matrix<_Ty, -1, -1> l = multiNormal.getCovL();
+			ret = (lowerBound + upperBound) / 2;
+			Eigen::Matrix<_Ty, -1, 1> z = l.template triangularView<Eigen::Lower>().solve(ret - multiNormal.mean),
+				a = lowerBound - multiNormal.mean,
+				b = upperBound - multiNormal.mean,
+				t, at, bt;
+			for (size_t i = 0; i < burnIn; ++i)
 			{
-				// shuffle sampling orders except during initialization
-				if (i) std::shuffle(ks.begin(), ks.end(), rng);
-				for (size_t kx = 0; kx < K; ++kx)
+				for (size_t j = 0; j < K; ++j)
 				{
-					size_t k = ks[kx];
-					ret[k] = 0;
-					//bias = multiNormal.mean + l * ret;
-					//bias.tail(K - k) = multiNormal.mean.tail(K - k) + l.block(k, 0, K - k, K) * ret;
-					bias.tail(K - k) = multiNormal.mean.tail(K - k);
-					bias.tail(K - k).noalias() += l.block(k, 0, K - k, K) * ret;
-					lowers = (lowerBound - bias).tail(K - k).array() / l.col(k).tail(K - k).array();
-					uppers = (upperBound - bias).tail(K - k).array() / l.col(k).tail(K - k).array();
-					_Ty nLower = lowers[0], nUpper = uppers[0];
-					if (l(k, k) < 0) std::swap(nLower, nUpper);
-					if (i)
+					auto lj = l.col(j);
+					z[j] = 0;
+					t = l * z;
+					_Ty lower_pos = -INFINITY, upper_pos = INFINITY,
+						lower_neg = -INFINITY, upper_neg = INFINITY;
+					at = ((a - t).array() / lj.array()).matrix();
+					bt = ((b - t).array() / lj.array()).matrix();
+					for (size_t k = 0; k < K; ++k)
 					{
-						for (size_t j = 1; j < lowers.size(); ++j)
+						if (lj[k] > 0)
+						{
+							lower_pos = std::max(lower_pos, at[k]);
+							upper_pos = std::min(upper_pos, bt[k]);
+						}
+						else if (lj[k] < 0)
 						{
-							if (l.col(k)(j + k) > epsilon)
-							{
-								if (lowers[j] > nLower) nLower = lowers[j];
-								if (uppers[j] < nUpper) nUpper = uppers[j];
-							}
-							else if (l.col(k)(j + k) < -epsilon)
-							{
-								if (uppers[j] > nLower) nLower = uppers[j];
-								if (lowers[j] < nUpper) nUpper = lowers[j];
-							}
+							lower_neg = std::max(lower_neg, bt[k]);
+							upper_neg = std::min(upper_neg, at[k]);
 						}
 					}
-					if (abs(nLower - nUpper) <= 1e-4) ret[k] = (nLower + nUpper) / 2;
+					lower_pos = std::max(lower_pos, lower_neg);
+					upper_pos = std::min(upper_pos, upper_neg);
+					// this is due to numerical instability
+					if (lower_pos >= upper_pos)
+					{
+						std::cerr << __FILE__ << "(" << __LINE__ << "): wrong truncation range [" << lower_pos << ", " << upper_pos << "]" << std::endl;
+						z[j] = (lower_pos + upper_pos) / 2;
+					}
 					else
 					{
-						ret[k] = rtnorm::rtnorm(rng, nLower, nUpper);
+						z[j] = rtnorm::rtnorm(rng, lower_pos, upper_pos);
 					}
 				}
 			}
-			ret = l * ret;
-			ret += multiNormal.mean;
+			ret = (l * z) + multiNormal.mean;
 			return ret;
 		}
 

data/vendor/tomotopy/src/Utils/Utils.hpp

@@ -70,7 +70,7 @@ namespace tomoto
 	}
 
 	template<class UnaryFunction>
-	UnaryFunction forRandom(size_t N, size_t seed, UnaryFunction f)
+	UnaryFunction forShuffled(size_t N, size_t seed, UnaryFunction f)
 	{
 		static size_t primes[16] = {
 			65537, 65539, 65543, 65551, 65557, 65563,
@@ -206,132 +206,137 @@ namespace tomoto
 	}
 
 	template <typename _UnaryFunc, typename _Iterator>
-	class TransformIter
+	class TransformIter : public _Iterator
 	{
 	private:
-		_Iterator i;
 		_UnaryFunc f;
 	public:
 		using reference = typename std::result_of<
 			const _UnaryFunc(typename std::iterator_traits<_Iterator>::reference)
 		>::type;
 		using value_type = reference;
-
-		using pointer = void;
-		using iterator_category = typename std::iterator_traits<_Iterator>::iterator_category;
-		using difference_type = typename std::iterator_traits<_Iterator>::difference_type;
-
+		
 		TransformIter(const _Iterator& _iter = {}, _UnaryFunc _f = {})
-			: i(_iter), f(_f)
+			: _Iterator(_iter), f(_f)
 		{}
 		
 		reference operator*()
 		{
-			return f(*i);
+			return f(_Iterator::operator*());
 		}
 
 		const reference operator*() const
 		{
-			return f(*i);
+			return f(_Iterator::operator*());
 		}
 
 		reference operator[](std::size_t idx)
 		{
-			return f(i[idx]);
+			return f(_Iterator::operator[](idx));
 		}
 
 		const reference operator[](std::size_t idx) const
 		{
-			return f(i[idx]);
+			return f(_Iterator::operator[](idx));
 		}
 
 		TransformIter& operator++()
 		{
-			++i;
+			_Iterator::operator++();
 			return *this;
 		}
 
-		TransformIter& operator++(int)
+		TransformIter operator++(int)
 		{
 			auto c = *this;
-			++i;
+			_Iterator::operator++();
 			return c;
 		}
 
 		TransformIter& operator--()
 		{
-			--i;
+			_Iterator::operator--();
 			return *this;
 		}
 
-		TransformIter& operator--(int)
+		TransformIter operator--(int)
 		{
 			auto c = *this;
-			--i;
+			_Iterator::operator--();
 			return c;
 		}
 
 		TransformIter operator+(int n) const
 		{
-			return { f, i + n };
+			return { _Iterator::operator+(n), f };
 		}
 
 		TransformIter operator-(int n) const
 		{
-			return { f, i - n };
+			return { _Iterator::operator-(n), f };
 		}
 
 		TransformIter& operator+=(int n)
 		{
-			i += n;
+			_Iterator::operator+=(n);
 			return *this;
 		}
 
 		TransformIter& operator-=(int n)
 		{
-			i -= n;
+			_Iterator::operator-=(n);
 			return *this;
 		}
 
 		typename std::iterator_traits<_Iterator>::difference_type operator-(const TransformIter& o) const
 		{
-			return i - o.i;
+			return (const _Iterator&)*this - (const _Iterator&)o;
 		}
 
-		bool operator==(const TransformIter& o) const
-		{
-			return i == o.i;
-		}
+	};
 
-		bool operator!=(const TransformIter& o) const
-		{
-			return i != o.i;
-		}
+	template <typename _UnaryFunc, typename _Iterator> 
+	TransformIter<_UnaryFunc, _Iterator> makeTransformIter(const _Iterator& iter, _UnaryFunc f)
+	{
+		return { iter, f };
+	}
 
-		bool operator<(const TransformIter& o) const
+	template <typename _Iterator>
+	class StrideIter : public _Iterator
+	{
+		size_t stride;
+		const _Iterator end;
+	public:
+		StrideIter(const _Iterator& iter, size_t _stride = 1, const _Iterator& _end = {})
+			: _Iterator{ iter }, stride{ _stride }, end{ _end }
 		{
-			return i < o.i;
 		}
 
-		bool operator>(const TransformIter& o) const
-		{
-			return i > o.i;
-		}
+		StrideIter(const StrideIter&) = default;
+		StrideIter(StrideIter&&) = default;
 
-		bool operator<=(const TransformIter& o) const
+		StrideIter& operator++()
 		{
-			return i <= o.i;
+			for (size_t i = 0; i < stride && *this != end; ++i)
+			{
+				_Iterator::operator++();
+			}
+			return *this;
 		}
 
-		bool operator>=(const TransformIter& o) const
+		StrideIter& operator--()
 		{
-			return i >= o.i;
+			for (size_t i = 0; i < stride && *this != end; ++i)
+			{
+				_Iterator::operator--();
+			}
+			return *this;
 		}
 	};
 
-	template <typename _UnaryFunc, typename _Iterator> 
-	TransformIter<_UnaryFunc, _Iterator> makeTransformIter(const _Iterator& iter, _UnaryFunc f)
+	template <typename _Iterator>
+	StrideIter<_Iterator> makeStrideIter(const _Iterator& iter, size_t stride, const _Iterator& end = {})
 	{
-		return { iter, f };
+		return { iter, stride, end };
 	}
 }