This file is indexed.

/usr/include/torch/SpeechHMM.h is in libtorch3-dev 3.1-2.1build1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
// Copyright (C) 2003--2004 Samy Bengio (bengio@idiap.ch)
//                
// This file is part of Torch 3.1.
//
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
// 3. The name of the author may not be used to endorse or promote products
//    derived from this software without specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#ifndef SPEECH_HMM_INC
#define SPEECH_HMM_INC

#include "HMM.h"
#include "LexiconInfo.h"
#include "EditDistance.h"
#include "log_add.h"
#include "EMTrainer.h"
#include "ExampleFrameSelectorDataSet.h"

namespace Torch {

/** This class implements a special case of Hidden Markov Models that
    can be used to do connected word speech recognition for small
    vocabulary, using embedded training.

    It contains a set of phoneme models (represented by HMMs), a lexicon
    of words (which are sequences of phonemes) 

    @author Samy Bengio (bengio@idiap.ch)
*/
class SpeechHMM : public HMM
{
  public:
    /// the number of basic phoneme models 
    int n_models;
    /// the basic phoneme models
    HMM** models;

    /// a dataset for initialization
		DataSet* data;
		
    /** if an initial alignment is given and an emtrainer for each model
        then it is used to train the models after kmeans during reset
    */
    EMTrainer** model_trainer;

		/// as well as a measurer of this trainer
    MeasurerList* initial_models_trainer_measurers;

    /// the acceptable lexicon
    LexiconInfo* lexicon;

    /// the current target sequence, with start and end words/phonemes
    Sequence* targets;
    /// number of words to add
    int add_to_targets;

    /// true if the given transition is a transition between words
    bool **word_transitions;

    /// the maximum number of states in the graph (used for allocation)
    int max_n_states;
    
    /// the relation between model states and SpeechHMM states
    int* states_to_model_states;

    /// the relation between models and SpeechHMM states
    int* states_to_model;

    /// the relation between words and SpeechHMM states
    int* states_to_word;
  
    /// are targets expressed in words or phonemes?
    bool phoneme_targets;

    /** In order to create a SpeechHMM, we need to give a vector of #n_models_#
        #HMM#s as well as their corresponding name, a lexicon,
        an optional log_word_entrance_penalty and an optional trainer that can be
        used to initialize each model independently.
    */
    SpeechHMM(int n_models_, HMM **models_, LexiconInfo* lex_, EMTrainer** model_trainer_ = NULL);

    virtual void setDataSet(DataSet* data_);
		void splitDataSet(DataSet* data_, ExampleFrameSelectorDataSet** split_data_);
    virtual void loadXFile(XFile *file);
    virtual void saveXFile(XFile *file);

    virtual void iterInitialize();
    virtual void eMIterInitialize();
    virtual void eMSequenceInitialize(Sequence* inputs);
    virtual void sequenceInitialize(Sequence* inputs);
    virtual void eMAccPosteriors(Sequence *inputs, real log_posterior);
    virtual void viterbiAccPosteriors(Sequence *inputs, real log_posterior);
    virtual void eMUpdate();


    /** this method prepare the transition graph associated with a
        given training sentence
    */
    virtual void prepareTrainModel(Sequence* input);

    /** this method is used by #prepareTrainModel# 
        to prepare the model. It adds a given word to the current graph.
    */
    virtual int addWordToModel(int word, int current_state);

    virtual	void setMaxNStates(int max_n_states_);

    /** this method is used by #prepareTrainModel#
        to prepare the model. It adds the connections between words.
    */
    virtual void addConnectionsBetweenWordsToModel(int word,int next_word, int current_state,int next_current_state, real log_n_next);

    /// this methods returns the number of states in a given word
    virtual int nStatesInWord(int word);

    /// this methods returns the number of states in a given word pronunciation
    virtual int nStatesInWordPronunciation(int word, int pronun);

    virtual void backward(Sequence *inputs, Sequence *alpha);

    virtual void setTargets(Sequence* t);

    virtual ~SpeechHMM();
};


}

#endif