summaryrefslogtreecommitdiff
path: root/kaldi_io/src/tools/openfst/include/fst/random-weight.h
diff options
context:
space:
mode:
authorDeterminant <[email protected]>2015-08-14 11:51:42 +0800
committerDeterminant <[email protected]>2015-08-14 11:51:42 +0800
commit96a32415ab43377cf1575bd3f4f2980f58028209 (patch)
tree30a2d92d73e8f40ac87b79f6f56e227bfc4eea6e /kaldi_io/src/tools/openfst/include/fst/random-weight.h
parentc177a7549bd90670af4b29fa813ddea32cfe0f78 (diff)
add implementation for kaldi io (by ymz)
Diffstat (limited to 'kaldi_io/src/tools/openfst/include/fst/random-weight.h')
-rw-r--r--kaldi_io/src/tools/openfst/include/fst/random-weight.h348
1 files changed, 348 insertions, 0 deletions
diff --git a/kaldi_io/src/tools/openfst/include/fst/random-weight.h b/kaldi_io/src/tools/openfst/include/fst/random-weight.h
new file mode 100644
index 0000000..0ccd95d
--- /dev/null
+++ b/kaldi_io/src/tools/openfst/include/fst/random-weight.h
@@ -0,0 +1,348 @@
+// random-weight.h
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Copyright 2005-2010 Google, Inc.
+// Author: [email protected] (Michael Riley)
+//
+// \file
+// Function objects to generate random weights in various semirings
+// for testing purposes.
+
+#ifndef FST_LIB_RANDOM_WEIGHT_H__
+#define FST_LIB_RANDOM_WEIGHT_H__
+
+#include <cstdlib>
+#include <ctime>
+#include <vector>
+using std::vector;
+
+
+#include <fst/float-weight.h>
+#include <fst/product-weight.h>
+#include <fst/string-weight.h>
+#include <fst/lexicographic-weight.h>
+#include <fst/power-weight.h>
+#include <fst/signed-log-weight.h>
+#include <fst/sparse-power-weight.h>
+
+
+namespace fst {
+
+// The boolean 'allow_zero' below determines whether Zero() and zero
+// divisors should be returned in the random weight generation.
+
+// This function object returns TropicalWeightTpl<T>'s that are random integers
+// chosen from [0, kNumRandomWeights).
+template <class T>
+class TropicalWeightGenerator_ {
+ public:
+ typedef TropicalWeightTpl<T> Weight;
+
+ TropicalWeightGenerator_(int seed = time(0), bool allow_zero = true)
+ : allow_zero_(allow_zero) {
+ srand(seed);
+ }
+
+ Weight operator() () const {
+ int n = rand() % (kNumRandomWeights + allow_zero_);
+ if (allow_zero_ && n == kNumRandomWeights)
+ return Weight::Zero();
+
+ return Weight(static_cast<T>(n));
+ }
+
+ private:
+ // The number of alternative random weights.
+ static const int kNumRandomWeights = 5;
+
+ bool allow_zero_; // permit Zero() and zero divisors
+};
+
+template <class T> const int TropicalWeightGenerator_<T>::kNumRandomWeights;
+
+typedef TropicalWeightGenerator_<float> TropicalWeightGenerator;
+
+
+// This function object returns LogWeightTpl<T>'s that are random integers
+// chosen from [0, kNumRandomWeights).
+template <class T>
+class LogWeightGenerator_ {
+ public:
+ typedef LogWeightTpl<T> Weight;
+
+ LogWeightGenerator_(int seed = time(0), bool allow_zero = true)
+ : allow_zero_(allow_zero) {
+ srand(seed);
+ }
+
+ Weight operator() () const {
+ int n = rand() % (kNumRandomWeights + allow_zero_);
+ if (allow_zero_ && n == kNumRandomWeights)
+ return Weight::Zero();
+
+ return Weight(static_cast<T>(n));
+ }
+
+ private:
+ // Number of alternative random weights.
+ static const int kNumRandomWeights = 5;
+
+ bool allow_zero_; // permit Zero() and zero divisors
+};
+
+template <class T> const int LogWeightGenerator_<T>::kNumRandomWeights;
+
+typedef LogWeightGenerator_<float> LogWeightGenerator;
+
+
+// This function object returns MinMaxWeightTpl<T>'s that are random integers
+// chosen from (-kNumRandomWeights, kNumRandomWeights) in addition to
+// One(), and Zero() if zero is allowed.
+template <class T>
+class MinMaxWeightGenerator_ {
+ public:
+ typedef MinMaxWeightTpl<T> Weight;
+
+ MinMaxWeightGenerator_(int seed = time(0), bool allow_zero = true)
+ : allow_zero_(allow_zero) {
+ srand(seed);
+ }
+
+ Weight operator() () const {
+ int n = (rand() % (2*kNumRandomWeights + allow_zero_)) - kNumRandomWeights;
+ if (allow_zero_ && n == kNumRandomWeights)
+ return Weight::Zero();
+ else if (n == -kNumRandomWeights)
+ return Weight::One();
+
+ return Weight(static_cast<T>(n));
+ }
+
+ private:
+ // Parameters controlling the number of alternative random weights.
+ static const int kNumRandomWeights = 5;
+
+ bool allow_zero_; // permit Zero() and zero divisors
+};
+
+template <class T> const int MinMaxWeightGenerator_<T>::kNumRandomWeights;
+
+typedef MinMaxWeightGenerator_<float> MinMaxWeightGenerator;
+
+
+// This function object returns StringWeights that are random integer
+// strings chosen from {1,...,kAlphabetSize}^{0,kMaxStringLength} U { Zero }
+template <typename L, StringType S = STRING_LEFT>
+class StringWeightGenerator {
+ public:
+ typedef StringWeight<L, S> Weight;
+
+ StringWeightGenerator(int seed = time(0), bool allow_zero = true)
+ : allow_zero_(allow_zero) {
+ srand(seed);
+ }
+
+ Weight operator() () const {
+ int n = rand() % (kMaxStringLength + allow_zero_);
+ if (allow_zero_ && n == kMaxStringLength)
+ return Weight::Zero();
+
+ vector<L> v;
+ for (int i = 0; i < n; ++i)
+ v.push_back(rand() % kAlphabetSize + 1);
+ return Weight(v.begin(), v.end());
+ }
+
+ private:
+ // Alphabet size for random weights.
+ static const int kAlphabetSize = 5;
+ // Number of alternative random weights.
+ static const int kMaxStringLength = 5;
+
+ bool allow_zero_; // permit Zero() and zero
+};
+
+template <typename L, StringType S>
+const int StringWeightGenerator<L, S>::kAlphabetSize;
+template <typename L, StringType S>
+const int StringWeightGenerator<L, S>::kMaxStringLength;
+
+
+// This function object returns a weight generator over the product of the
+// weights (by default) for the generators G1 and G2.
+template <class G1, class G2,
+ class W = ProductWeight<typename G1::Weight, typename G2::Weight> >
+class ProductWeightGenerator {
+ public:
+ typedef typename G1::Weight W1;
+ typedef typename G2::Weight W2;
+ typedef W Weight;
+
+ ProductWeightGenerator(int seed = time(0), bool allow_zero = true)
+ : generator1_(seed, allow_zero), generator2_(seed, allow_zero) {}
+
+ Weight operator() () const {
+ W1 w1 = generator1_();
+ W2 w2 = generator2_();
+ return Weight(w1, w2);
+ }
+
+ private:
+ G1 generator1_;
+ G2 generator2_;
+};
+
+
+// This function object returns a weight generator for a lexicographic weight
+// composed out of weights for the generators G1 and G2. For lexicographic
+// weights, we cannot generate zeroes for the two subweights separately:
+// weights are members iff both members are zero or both members are non-zero.
+template <class G1, class G2>
+class LexicographicWeightGenerator {
+ public:
+ typedef typename G1::Weight W1;
+ typedef typename G2::Weight W2;
+ typedef LexicographicWeight<W1, W2> Weight;
+
+ LexicographicWeightGenerator(int seed = time(0), bool allow_zero = true)
+ : generator1_(seed, false), generator2_(seed, false),
+ allow_zero_(allow_zero) {}
+
+ Weight operator() () const {
+ if (allow_zero_) {
+ int n = rand() % (kNumRandomWeights + allow_zero_);
+ if (n == kNumRandomWeights)
+ return Weight(W1::Zero(), W2::Zero());
+ }
+ W1 w1 = generator1_();
+ W2 w2 = generator2_();
+ return Weight(w1, w2);
+ }
+
+ private:
+ G1 generator1_;
+ G2 generator2_;
+ static const int kNumRandomWeights = 5;
+ bool allow_zero_;
+};
+
+template <class G1, class G2>
+const int LexicographicWeightGenerator<G1, G2>::kNumRandomWeights;
+
+
+// Product generator of a string weight generator and an
+// arbitrary weight generator.
+template <class L, class G, StringType S = STRING_LEFT>
+class GallicWeightGenerator
+ : public ProductWeightGenerator<StringWeightGenerator<L, S>, G> {
+
+ public:
+ typedef ProductWeightGenerator<StringWeightGenerator<L, S>, G> PG;
+ typedef typename G::Weight W;
+ typedef GallicWeight<L, W, S> Weight;
+
+ GallicWeightGenerator(int seed = time(0), bool allow_zero = true)
+ : PG(seed, allow_zero) {}
+
+ GallicWeightGenerator(const PG &pg) : PG(pg) {}
+};
+
+// This function object returms a weight generator over the catersian power
+// of rank n of the weights for the generator G.
+template <class G, unsigned int n>
+class PowerWeightGenerator {
+ public:
+ typedef typename G::Weight W;
+ typedef PowerWeight<W, n> Weight;
+
+ PowerWeightGenerator(int seed = time(0), bool allow_zero = true)
+ : generator_(seed, allow_zero) {}
+
+ Weight operator()() const {
+ Weight w;
+ for (size_t i = 0; i < n; ++i) {
+ W r = generator_();
+ w.SetValue(i, r);
+ }
+ return w;
+ }
+
+ private:
+ G generator_;
+};
+
+// This function object returns SignedLogWeightTpl<T>'s that are
+// random integers chosen from [0, kNumRandomWeights).
+// The sign is randomly chosen as well.
+template <class T>
+class SignedLogWeightGenerator_ {
+ public:
+ typedef SignedLogWeightTpl<T> Weight;
+
+ SignedLogWeightGenerator_(int seed = time(0), bool allow_zero = true)
+ : allow_zero_(allow_zero) {
+ srand(seed);
+ }
+
+ Weight operator() () const {
+ int m = rand() % 2;
+ int n = rand() % (kNumRandomWeights + allow_zero_);
+
+ return SignedLogWeightTpl<T>(
+ (m == 0) ?
+ TropicalWeight(-1.0) :
+ TropicalWeight(1.0),
+ (allow_zero_ && n == kNumRandomWeights) ?
+ LogWeightTpl<T>::Zero() :
+ LogWeightTpl<T>(static_cast<T>(n)));
+ }
+
+ private:
+ // Number of alternative random weights.
+ static const int kNumRandomWeights = 5;
+ bool allow_zero_; // permit Zero() and zero divisors
+};
+
+template <class T> const int SignedLogWeightGenerator_<T>::kNumRandomWeights;
+
+typedef SignedLogWeightGenerator_<float> SignedLogWeightGenerator;
+
+// This function object returms a weight generator over the catersian power
+// of rank n of the weights for the generator G.
+template <class G, class K, unsigned int n>
+class SparsePowerWeightGenerator {
+ public:
+ typedef typename G::Weight W;
+ typedef SparsePowerWeight<W, K> Weight;
+
+ SparsePowerWeightGenerator(int seed = time(0), bool allow_zero = true)
+ : generator_(seed, allow_zero) {}
+
+ Weight operator()() const {
+ Weight w;
+ for (size_t i = 1; i <= n; ++i) {
+ W r = generator_();
+ K p = i;
+ w.Push(p, r, true);
+ }
+ return w;
+ }
+
+ private:
+ G generator_;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_RANDOM_WEIGHT_H__