Exemplo n.º 1
0
            private SentenceHMMState attachUnit(PronunciationState parent, SentenceHMMState sentenceHMMState, Unit[] array, int num, UnitContext unitContext, UnitContext unitContext2)
            {
                Unit[]            lc                = this.getLC(unitContext, array, num);
                Unit[]            rc                = this.getRC(array, num, unitContext2);
                UnitContext       unitContext3      = UnitContext.get(rc);
                LeftRightContext  context           = LeftRightContext.get(lc, rc);
                Unit              unit              = FlatLinguist.access_200(this.this_0).getUnit(array[num].getName(), array[num].isFiller(), context);
                ExtendedUnitState extendedUnitState = new ExtendedUnitState(parent, num, unit);
                float             logInsertionProbablity;

                if (extendedUnitState.getUnit().isSilence())
                {
                    logInsertionProbablity = FlatLinguist.access_300(this.this_0);
                }
                else if (extendedUnitState.getUnit().isFiller())
                {
                    logInsertionProbablity = FlatLinguist.access_400(this.this_0);
                }
                else if (extendedUnitState.getWhich() == 0)
                {
                    logInsertionProbablity = FlatLinguist.access_500(this.this_0);
                }
                else
                {
                    logInsertionProbablity = FlatLinguist.access_600(this.this_0);
                }
                SentenceHMMState existingState = this.getExistingState(extendedUnitState);

                if (existingState != null)
                {
                    this.attachState(sentenceHMMState, existingState, 0f, logInsertionProbablity);
                    return(null);
                }
                this.attachState(sentenceHMMState, extendedUnitState, 0f, logInsertionProbablity);
                this.addStateToCache(extendedUnitState);
                sentenceHMMState = this.expandUnit(extendedUnitState);
                if (extendedUnitState.isLast())
                {
                    UnitContext unitContext4 = this.generateNextLeftContext(unitContext, array[num]);
                    ContextPair contextPair  = ContextPair.get(unitContext4, unitContext3);
                    this.addExitPoint(contextPair, sentenceHMMState);
                }
                return(sentenceHMMState);
            }
        private SenoneHMM getHMMInSilenceContext(Unit unit, HMMPosition position)
        {
            SenoneHMM  senoneHMM  = null;
            HMMManager hmmmanager = this.loader.getHMMManager();
            Context    context    = unit.getContext();

            if (context is LeftRightContext)
            {
                LeftRightContext leftRightContext = (LeftRightContext)context;
                Unit[]           leftContext      = leftRightContext.getLeftContext();
                Unit[]           rightContext     = leftRightContext.getRightContext();
                Unit[]           array;
                if (this.hasNonSilenceFiller(leftContext))
                {
                    array = this.replaceNonSilenceFillerWithSilence(leftContext);
                }
                else
                {
                    array = leftContext;
                }
                Unit[] array2;
                if (this.hasNonSilenceFiller(rightContext))
                {
                    array2 = this.replaceNonSilenceFillerWithSilence(rightContext);
                }
                else
                {
                    array2 = rightContext;
                }
                if (array != leftContext || array2 != rightContext)
                {
                    LeftRightContext context2 = LeftRightContext.get(array, array2);
                    Unit             unit2    = this.unitManager.getUnit(unit.getName(), unit.isFiller(), context2);
                    senoneHMM = (SenoneHMM)hmmmanager.get(position, unit2);
                    if (senoneHMM == null)
                    {
                        senoneHMM = this.getHMMAtAnyPosition(unit2);
                    }
                }
            }
            return(senoneHMM);
        }
Exemplo n.º 3
0
        protected internal virtual void loadHMMPool(bool useCDUnits, InputStream inputStream)
        {
            ExtendedStreamTokenizer extendedStreamTokenizer = new ExtendedStreamTokenizer(inputStream, 35, false);

            this.logger.fine(new StringBuilder().append("Loading HMM file from: ").append(this.location).toString());
            extendedStreamTokenizer.expectString("0.3");
            int @int = extendedStreamTokenizer.getInt("numBase");

            extendedStreamTokenizer.expectString("n_base");
            int int2 = extendedStreamTokenizer.getInt("numTri");

            extendedStreamTokenizer.expectString("n_tri");
            int int3 = extendedStreamTokenizer.getInt("numStateMap");

            extendedStreamTokenizer.expectString("n_state_map");
            int int4 = extendedStreamTokenizer.getInt("numTiedState");

            extendedStreamTokenizer.expectString("n_tied_state");
            int int5 = extendedStreamTokenizer.getInt("numContextIndependentTiedState");

            extendedStreamTokenizer.expectString("n_tied_ci_state");
            int int6 = extendedStreamTokenizer.getInt("numTiedTransitionMatrices");

            extendedStreamTokenizer.expectString("n_tied_tmat");
            int num  = int3;
            int num2 = int2 + @int;
            int num3 = (num2 != -1) ? (num / num2) : (-num);

            if (!Sphinx3Loader.assertionsDisabled && int4 != this.mixtureWeights.getStatesNum())
            {
                throw new AssertionError();
            }
            if (!Sphinx3Loader.assertionsDisabled && int6 != this.transitionsPool.size())
            {
                throw new AssertionError();
            }
            for (int i = 0; i < @int; i++)
            {
                string @string = extendedStreamTokenizer.getString();
                string string2 = extendedStreamTokenizer.getString();
                string string3 = extendedStreamTokenizer.getString();
                string string4 = extendedStreamTokenizer.getString();
                string string5 = extendedStreamTokenizer.getString();
                int    int7    = extendedStreamTokenizer.getInt("tmat");
                int[]  array   = new int[num3 - 1];
                for (int j = 0; j < num3 - 1; j++)
                {
                    array[j] = extendedStreamTokenizer.getInt("j");
                    if (!Sphinx3Loader.assertionsDisabled && (array[j] < 0 || array[j] >= int5))
                    {
                        throw new AssertionError();
                    }
                }
                extendedStreamTokenizer.expectString("N");
                if (!Sphinx3Loader.assertionsDisabled && !String.instancehelper_equals(string2, "-"))
                {
                    throw new AssertionError();
                }
                if (!Sphinx3Loader.assertionsDisabled && !String.instancehelper_equals(string3, "-"))
                {
                    throw new AssertionError();
                }
                if (!Sphinx3Loader.assertionsDisabled && !String.instancehelper_equals(string4, "-"))
                {
                    throw new AssertionError();
                }
                if (!Sphinx3Loader.assertionsDisabled && int7 >= int6)
                {
                    throw new AssertionError();
                }
                Unit unit = this.unitManager.getUnit(@string, String.instancehelper_equals(string5, "filler"));
                this.contextIndependentUnits.put(unit.getName(), unit);
                if (this.logger.isLoggable(Level.FINE))
                {
                    this.logger.fine(new StringBuilder().append("Loaded ").append(unit).toString());
                }
                if (unit.isFiller() && String.instancehelper_equals(unit.getName(), "SIL"))
                {
                    unit = UnitManager.__SILENCE;
                }
                float[][]      transitionMatrix = (float[][])this.transitionsPool.get(int7);
                SenoneSequence senoneSequence   = this.getSenoneSequence(array);
                SenoneHMM      hmm = new SenoneHMM(unit, senoneSequence, transitionMatrix, HMMPosition.lookup(string4));
                this.hmmManager.put(hmm);
            }
            if (this.hmmManager.get(HMMPosition.__UNDEFINED, UnitManager.__SILENCE) == null)
            {
                string text = "Could not find SIL unit in acoustic model";

                throw new IOException(text);
            }
            string text2 = "";
            Unit   unit2 = null;

            int[]          ssid            = null;
            SenoneSequence senoneSequence2 = null;

            for (int k = 0; k < int2; k++)
            {
                string string5 = extendedStreamTokenizer.getString();
                string string6 = extendedStreamTokenizer.getString();
                string string7 = extendedStreamTokenizer.getString();
                string string8 = extendedStreamTokenizer.getString();
                string string9 = extendedStreamTokenizer.getString();
                int    int8    = extendedStreamTokenizer.getInt("tmat");
                int[]  array2  = new int[num3 - 1];
                for (int l = 0; l < num3 - 1; l++)
                {
                    array2[l] = extendedStreamTokenizer.getInt("j");
                    if (!Sphinx3Loader.assertionsDisabled && (array2[l] < int5 || array2[l] >= int4))
                    {
                        throw new AssertionError();
                    }
                }
                extendedStreamTokenizer.expectString("N");
                if (!Sphinx3Loader.assertionsDisabled && String.instancehelper_equals(string6, "-"))
                {
                    throw new AssertionError();
                }
                if (!Sphinx3Loader.assertionsDisabled && String.instancehelper_equals(string7, "-"))
                {
                    throw new AssertionError();
                }
                if (!Sphinx3Loader.assertionsDisabled && String.instancehelper_equals(string8, "-"))
                {
                    throw new AssertionError();
                }
                if (!Sphinx3Loader.assertionsDisabled && !String.instancehelper_equals(string9, "n/a"))
                {
                    throw new AssertionError();
                }
                if (!Sphinx3Loader.assertionsDisabled && int8 >= int6)
                {
                    throw new AssertionError();
                }
                if (useCDUnits)
                {
                    string text3 = new StringBuilder().append(string5).append(' ').append(string6).append(' ').append(string7).toString();
                    Unit   unit3;
                    if (String.instancehelper_equals(text3, text2))
                    {
                        unit3 = unit2;
                    }
                    else
                    {
                        LeftRightContext context = LeftRightContext.get(new Unit[]
                        {
                            (Unit)this.contextIndependentUnits.get(string6)
                        }, new Unit[]
                        {
                            (Unit)this.contextIndependentUnits.get(string7)
                        });
                        unit3 = this.unitManager.getUnit(string5, false, context);
                    }
                    text2 = text3;
                    unit2 = unit3;
                    if (this.logger.isLoggable(Level.FINE))
                    {
                        this.logger.fine(new StringBuilder().append("Loaded ").append(unit3).toString());
                    }
                    float[][]      transitionMatrix2 = (float[][])this.transitionsPool.get(int8);
                    SenoneSequence senoneSequence3   = senoneSequence2;
                    if (senoneSequence3 == null || !this.sameSenoneSequence(array2, ssid))
                    {
                        senoneSequence3 = this.getSenoneSequence(array2);
                    }
                    senoneSequence2 = senoneSequence3;
                    ssid            = array2;
                    SenoneHMM hmm2 = new SenoneHMM(unit3, senoneSequence3, transitionMatrix2, HMMPosition.lookup(string8));
                    this.hmmManager.put(hmm2);
                }
            }
            extendedStreamTokenizer.close();
        }
Exemplo n.º 4
0
        protected internal virtual void loadHMMPool(bool useCDUnits, HTKLoader.HTKStruct htkModels, string path)
        {
            if (!this.tie1ph)
            {
                Iterator iterator = htkModels.hmmsHTK.get1phIt();
                while (iterator.hasNext())
                {
                    SingleHMM singleHMM = (SingleHMM)iterator.next();
                    if (singleHMM == null)
                    {
                        break;
                    }
                    string baseName = singleHMM.getName();
                    string text;
                    if (String.instancehelper_equals(baseName, "sil") || String.instancehelper_equals(baseName, "sp") || String.instancehelper_equals(baseName, "bb") || String.instancehelper_equals(baseName, "xx") || String.instancehelper_equals(baseName, "hh"))
                    {
                        text = "filler";
                    }
                    else
                    {
                        text = "nofiller";
                    }
                    int   trIdx   = singleHMM.trIdx;
                    int   nstates = singleHMM.getNstates();
                    int[] array   = new int[singleHMM.getNbEmittingStates()];
                    int   num     = 0;
                    for (int i = 0; i < nstates; i++)
                    {
                        if (singleHMM.isEmitting(i))
                        {
                            HTK.HMMState state = singleHMM.getState(i);
                            array[num] = htkModels.hmmsHTK.getStateIdx(state);
                            num++;
                        }
                    }
                    Unit unit = this.unitManager.getUnit(baseName, String.instancehelper_equals(text, "filler"));
                    this.contextIndependentUnits.put(unit.getName(), unit);
                    if (this.logger.isLoggable(Level.FINE))
                    {
                        this.logger.fine(new StringBuilder().append("Loaded ").append(unit).toString());
                    }
                    if (unit.isFiller() && String.instancehelper_equals(unit.getName(), "SIL"))
                    {
                        unit = UnitManager.__SILENCE;
                    }
                    float[][]      transitionMatrix = (float[][])this.matrixPool.get(trIdx);
                    SenoneSequence senoneSequence   = this.getSenoneSequence(array);
                    SenoneHMM      hmm = new SenoneHMM(unit, senoneSequence, transitionMatrix, HMMPosition.lookup("-"));
                    this.hmmManager.put(hmm);
                }
            }
            else
            {
                for (int j = 0; j < htkModels.hmmsHTK.getNhmms(); j++)
                {
                    SingleHMM singleHMM = htkModels.hmmsHTK.getHMM(j);
                    if (singleHMM == null)
                    {
                        break;
                    }
                    string baseName = singleHMM.getBaseName();
                    if (!this.contextIndependentUnits.containsKey(baseName))
                    {
                        string text;
                        if (String.instancehelper_equals(baseName, "SIL") || String.instancehelper_equals(baseName, "SP") || String.instancehelper_equals(baseName, "BB") || String.instancehelper_equals(baseName, "XX") || String.instancehelper_equals(baseName, "HH"))
                        {
                            text = "filler";
                        }
                        else
                        {
                            text = "nofiller";
                        }
                        int   trIdx   = singleHMM.trIdx;
                        int   nstates = singleHMM.getNstates();
                        int[] array   = new int[singleHMM.getNbEmittingStates()];
                        int   num     = 0;
                        for (int i = 0; i < nstates; i++)
                        {
                            if (singleHMM.isEmitting(i))
                            {
                                HTK.HMMState state = singleHMM.getState(i);
                                array[num] = htkModels.hmmsHTK.getStateIdx(state);
                                num++;
                            }
                        }
                        Unit unit = this.unitManager.getUnit(baseName, String.instancehelper_equals(text, "filler"));
                        this.contextIndependentUnits.put(unit.getName(), unit);
                        if (this.logger.isLoggable(Level.FINE))
                        {
                            this.logger.fine(new StringBuilder().append("Loaded ").append(unit).toString());
                        }
                        if (unit.isFiller() && String.instancehelper_equals(unit.getName(), "SIL"))
                        {
                            unit = UnitManager.__SILENCE;
                        }
                        float[][]      transitionMatrix = (float[][])this.matrixPool.get(trIdx);
                        SenoneSequence senoneSequence   = this.getSenoneSequence(array);
                        SenoneHMM      hmm = new SenoneHMM(unit, senoneSequence, transitionMatrix, HMMPosition.lookup("-"));
                        this.hmmManager.put(hmm);
                    }
                }
            }
            string text2 = "";
            Unit   unit2 = null;

            int[]          ssid            = null;
            SenoneSequence senoneSequence2 = null;
            ArrayList      arrayList       = new ArrayList();
            Iterator       iterator2       = htkModels.hmmsHTK.get3phIt();

            while (iterator2.hasNext())
            {
                SingleHMM singleHMM2 = (SingleHMM)iterator2.next();
                if (singleHMM2 == null)
                {
                    break;
                }
                string baseName2 = singleHMM2.getBaseName();
                string text3     = singleHMM2.getLeft();
                string text4     = singleHMM2.getRight();
                if (String.instancehelper_equals(text3, "-"))
                {
                    text3 = "SIL";
                }
                if (String.instancehelper_equals(text4, "-"))
                {
                    text4 = "SIL";
                }
                string text5 = new StringBuilder().append(text3).append(' ').append(baseName2).append(' ').append(text4).toString();
                if (!arrayList.contains(text5))
                {
                    arrayList.add(text5);
                    text5 = "i";
                    int   trIdx2  = singleHMM2.trIdx;
                    int   nstates = singleHMM2.getNstates();
                    int[] array2  = new int[singleHMM2.getNbEmittingStates()];
                    int   num2    = 0;
                    for (int k = 0; k < nstates; k++)
                    {
                        if (singleHMM2.isEmitting(k))
                        {
                            HTK.HMMState state2 = singleHMM2.getState(k);
                            array2[num2] = htkModels.hmmsHTK.getStateIdx(state2);
                            num2++;
                        }
                    }
                    if (useCDUnits)
                    {
                        string text6 = new StringBuilder().append(baseName2).append(' ').append(text3).append(' ').append(text4).toString();
                        Unit   unit3;
                        if (String.instancehelper_equals(text6, text2))
                        {
                            unit3 = unit2;
                        }
                        else
                        {
                            LeftRightContext context = LeftRightContext.get(new Unit[]
                            {
                                (Unit)this.contextIndependentUnits.get(text3)
                            }, new Unit[]
                            {
                                (Unit)this.contextIndependentUnits.get(text4)
                            });
                            unit3 = this.unitManager.getUnit(baseName2, false, context);
                        }
                        text2 = text6;
                        unit2 = unit3;
                        if (this.logger.isLoggable(Level.FINE))
                        {
                            this.logger.fine(new StringBuilder().append("Loaded ").append(unit3).toString());
                        }
                        float[][]      transitionMatrix2 = (float[][])this.matrixPool.get(trIdx2);
                        SenoneSequence senoneSequence3   = senoneSequence2;
                        if (senoneSequence3 == null || !this.sameSenoneSequence(array2, ssid))
                        {
                            senoneSequence3 = this.getSenoneSequence(array2);
                        }
                        senoneSequence2 = senoneSequence3;
                        ssid            = array2;
                        SenoneHMM hmm2 = new SenoneHMM(unit3, senoneSequence3, transitionMatrix2, HMMPosition.lookup(text5));
                        this.hmmManager.put(hmm2);
                    }
                }
            }
        }