Open-source speech recognition toolkit for training, inference, streaming ASR, VAD, punctuation, speaker diarization pipelines, and OpenAI-compatible/MCP serving.
Python asraudiochineseemotion-recognitionfunasrmcp-servermultilingual-asropenai-compatible-apiparaformerpunctuationpytorchreal-time-asrspeaker-diarizationspeech-recognitionspeech-to-textstreaming-asrtranscriptionvllmvoice-activity-detectionwhisper-alternative
// See www.openfst.org for extensive documentation on this weighted
// finite-state transducer library.
//
// Expectation semiring as described by Jason Eisner:
// See: doi=10.1.1.22.9398
// Multiplex semiring operations and identities:
// One: <One, Zero>
// Zero: <Zero, Zero>
// Plus: <a1, b1> + <a2, b2> = < (a1 + a2) , (b1 + b2) >
// Times: <a1, b1> * <a2, b2> = < (a1 * a2) , [(a1 * b2) + (a2 * b1)] >
// Division: Undefined (currently)
//
// Usually used to store the pair <probability, random_variable> so that
// ShortestDistance[Fst<ArcTpl<ExpectationWeight<P, V>>>]
// == < PosteriorProbability, Expected_Value[V] >
#ifndef FST_EXPECTATION_WEIGHT_H_
#define FST_EXPECTATION_WEIGHT_H_
#include <string>
#include <fst/log.h>
#include <fst/pair-weight.h>
#include <fst/product-weight.h>
namespace fst {
// X1 is usually a probability weight like LogWeight.
// X2 is usually a random variable or vector (see SignedLogWeight or
// SparsePowerWeight).
//
// If X1 is distinct from X2, it is required that there is an external product
// between X1 and X2 and if both semriring are commutative, or left or right
// semirings, then result must have those properties.
template <class X1, class X2>
class ExpectationWeight : public PairWeight<X1, X2> {
public:
using PairWeight<X1, X2>::Value1;
using PairWeight<X1, X2>::Value2;
using PairWeight<X1, X2>::Reverse;
using PairWeight<X1, X2>::Quantize;
using PairWeight<X1, X2>::Member;
using ReverseWeight =
ExpectationWeight<typename X1::ReverseWeight, typename X2::ReverseWeight>;
ExpectationWeight() : PairWeight<X1, X2>(Zero()) {}
explicit ExpectationWeight(const PairWeight<X1, X2> &weight)
: PairWeight<X1, X2>(weight) {}
ExpectationWeight(const X1 &x1, const X2 &x2) : PairWeight<X1, X2>(x1, x2) {}
static const ExpectationWeight &Zero() {
static const ExpectationWeight zero(X1::Zero(), X2::Zero());
return zero;
}
static const ExpectationWeight &One() {
static const ExpectationWeight one(X1::One(), X2::Zero());
return one;
}
static const ExpectationWeight &NoWeight() {
static const ExpectationWeight no_weight(X1::NoWeight(), X2::NoWeight());
return no_weight;
}
static const string &Type() {
static const string *const type =
new string("expectation_" + X1::Type() + "_" + X2::Type());
return *type;
}
PairWeight<X1, X2> Quantize(float delta = kDelta) const {
return ExpectationWeight(PairWeight<X1, X2>::Quantize());
}
ReverseWeight Reverse() const {
return ReverseWeight(PairWeight<X1, X2>::Reverse());
}
bool Member() const { return PairWeight<X1, X2>::Member(); }
static constexpr uint64 Properties() {
return X1::Properties() & X2::Properties() &
(kLeftSemiring | kRightSemiring | kCommutative | kIdempotent);
}
};
template <class X1, class X2>
inline ExpectationWeight<X1, X2> Plus(const ExpectationWeight<X1, X2> &w1,
const ExpectationWeight<X1, X2> &w2) {
return ExpectationWeight<X1, X2>(Plus(w1.Value1(), w2.Value1()),
Plus(w1.Value2(), w2.Value2()));
}
template <class X1, class X2>
inline ExpectationWeight<X1, X2> Times(const ExpectationWeight<X1, X2> &w1,
const ExpectationWeight<X1, X2> &w2) {
return ExpectationWeight<X1, X2>(
Times(w1.Value1(), w2.Value1()),
Plus(Times(w1.Value1(), w2.Value2()), Times(w1.Value2(), w2.Value1())));
}
template <class X1, class X2>
inline ExpectationWeight<X1, X2> Divide(const ExpectationWeight<X1, X2> &w1,
const ExpectationWeight<X1, X2> &w2,
DivideType typ = DIVIDE_ANY) {
FSTERROR() << "ExpectationWeight::Divide: Not implemented";
return ExpectationWeight<X1, X2>::NoWeight();
}
// This function object generates weights by calling the underlying generators
// for the template weight types, like all other pair weight types. This is
// intended primarily for testing.
template <class X1, class X2>
class WeightGenerate<ExpectationWeight<X1, X2>>
: public WeightGenerate<PairWeight<X1, X2>> {
public:
using Weight = ExpectationWeight<X1, X2>;
using Generate = WeightGenerate<PairWeight<X1, X2>>;
explicit WeightGenerate(bool allow_zero = true) : Generate(allow_zero) {}
Weight operator()() const { return Weight(Generate::operator()()); }
};
} // namespace fst
#endif // FST_EXPECTATION_WEIGHT_H_