| OpenMS 2.5.0

HiddenMarkovModel.h
Go to the documentation of this file.
1 // --------------------------------------------------------------------------
2 // OpenMS -- Open-Source Mass Spectrometry
3 // --------------------------------------------------------------------------
4 // Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
5 // ETH Zurich, and Freie Universitaet Berlin 2002-2020.
6 //
7 // This software is released under a three-clause BSD license:
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above copyright
11 // notice, this list of conditions and the following disclaimer in the
12 // documentation and/or other materials provided with the distribution.
13 // * Neither the name of any author or any participating institution
14 // may be used to endorse or promote products derived from this software
15 // without specific prior written permission.
16 // For a full list of authors, refer to the file AUTHORS.
17 // --------------------------------------------------------------------------
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 // ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
22 // INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
25 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
27 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
28 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 //
30 // --------------------------------------------------------------------------
31 // $Maintainer: Timo Sachsenberg $
32 // $Authors: Andreas Bertsch $
33 // --------------------------------------------------------------------------
34
35
36 #pragma once
37
38 #include <vector>
39 #include <set>
40
41 #include <OpenMS/DATASTRUCTURES/Map.h>
42 #include <OpenMS/CONCEPT/Types.h>
43 #include <OpenMS/DATASTRUCTURES/StringListUtils.h>
44 #include <OpenMS/DATASTRUCTURES/String.h>
45
46 #include <utility>
47
48 namespace OpenMS
49 {
53 class OPENMS_DLLAPI HMMState
54 {
55 public:
56
60 HMMState();
62
64 HMMState(const HMMState & state);
65
67 HMMState(const String & name, bool hidden = true);
68
70 virtual ~HMMState();
72
74 HMMState & operator=(const HMMState &);
75
79 void setName(const String & name);
81
83 const String & getName() const;
84
86 void setHidden(bool hidden);
87
89 bool isHidden() const;
90
92 void addPredecessorState(HMMState * state);
93
95 void deletePredecessorState(HMMState * state);
96
98 void addSuccessorState(HMMState * state);
99
101 void deleteSuccessorState(HMMState * state);
102
104 const std::set<HMMState *> & getPredecessorStates() const;
105
107 const std::set<HMMState *> & getSuccessorStates() const;
109
110 protected:
111
113 bool hidden_;
114
116 String name_;
117
119 std::set<HMMState *> pre_states_;
120
122 std::set<HMMState *> succ_states_;
123 };
124
125
133 class OPENMS_DLLAPI HiddenMarkovModel
134 {
135 public:
136
140 HiddenMarkovModel();
142
144 HiddenMarkovModel(const HiddenMarkovModel & hmm_new);
145
147 virtual ~HiddenMarkovModel();
149
151 HiddenMarkovModel & operator=(const HiddenMarkovModel &);
152
161 void writeGraphMLFile(const String & filename);
162
164 void write(std::ostream & out) const;
165
167 double getTransitionProbability(const String & s1, const String & s2) const;
168
170 void setTransitionProbability(const String & s1, const String & s2, double prob);
171
173 Size getNumberOfStates() const;
174
176 void addNewState(HMMState * state);
177
179 void addNewState(const String & name);
180
182 void addSynonymTransition(const String & name1, const String & name2, const String & synonym1, const String & synonym2);
183
185 void evaluate();
186
188 void train();
189
191 void setInitialTransitionProbability(const String & state, double prob);
192
194 void clearInitialTransitionProbabilities();
195
197 void setTrainingEmissionProbability(const String & state, double prob);
198
200 void clearTrainingEmissionProbabilities();
201
203 void enableTransition(const String & s1, const String & s2);
204
206 void disableTransition(const String & s1, const String & s2);
207
209 void disableTransitions();
210
212 void calculateEmissionProbabilities(Map<HMMState *, double> & emission_probs);
213
215 void dump();
216
218 void forwardDump();
219
221 //void buildSynonyms();
222
224 void estimateUntrainedTransitions();
225
227 HMMState * getState(const String & name);
228
230 const HMMState * getState(const String & name) const;
231
233 void clear();
234
236 void setPseudoCounts(double pseudo_counts);
237
239 double getPseudoCounts() const;
240
241 void setVariableModifications(const StringList & modifications);
243
244 protected:
245
247 void disableTransition_(HMMState * s1, HMMState * s2);
248
250 void enableTransition_(HMMState * s1, HMMState * s2);
251
253 void setTrainingEmissionProbability_(HMMState * state, double prob);
254
256 void setTransitionProbability_(HMMState * s1, HMMState * s2, double prob);
257
259 double getTransitionProbability_(HMMState * s1, HMMState * s2) const;
260
261
263 void calculateForwardPart_();
264
266 void calculateBackwardPart_();
267
269 double getForwardVariable_(HMMState *);
270
272 double getBackwardVariable_(HMMState *);
273
274 private:
275
276 // transition probs
277 Map<HMMState *, Map<HMMState *, double> > trans_;
278
279 // transition prob counts
280 Map<HMMState *, Map<HMMState *, double> > count_trans_;
281
282 Map<HMMState *, Map<HMMState *, std::vector<double> > > count_trans_all_;
283
284 // all transition probs of all training steps (for model checking)
285 Map<HMMState *, Map<HMMState *, std::vector<double> > > train_count_trans_all_;
286
287 // number of training steps of the transitions
288 Map<HMMState *, Map<HMMState *, Size> > training_steps_count_;
289
290 // forward variables
291 Map<HMMState *, double> forward_;
292
293 // backward variables
294 Map<HMMState *, double> backward_;
295
296 // name to state Mapping
297 Map<String, HMMState *> name_to_state_;
298
299 // emission probabilities
300 Map<HMMState *, double> train_emission_prob_;
301
302 // initial transition probabilities
303 Map<HMMState *, double> init_prob_;
304
305 // all states of the HMM
306 std::set<HMMState *> states_;
307
308 // trained transitions
309 std::set<std::pair<HMMState *, HMMState *> > trained_trans_;
310
311 // synonym transitions Mapping
312 Map<String, Map<String, std::pair<String, String> > > synonym_trans_names_;
313
314 // synonym transitions
315 Map<HMMState *, Map<HMMState *, std::pair<HMMState *, HMMState *> > > synonym_trans_;
316
317 // transitions which are enabled
318 Map<HMMState *, std::set<HMMState *> > enabled_trans_;
319
320 // pseudocounts used in this instance
321 double pseudo_counts_;
322
323 // copy all the stuff from one HMM to this
324 void copy_(const HiddenMarkovModel & source);
325
326 StringList var_modifications_;
327 };
328 }
OpenMS::HiddenMarkovModel::training_steps_count_
Map< HMMState *, Map< HMMState *, Size > > training_steps_count_
Definition: HiddenMarkovModel.h:288
OpenMS::HiddenMarkovModel::trans_
Map< HMMState *, Map< HMMState *, double > > trans_
Definition: HiddenMarkovModel.h:277
OpenMS::String
A more convenient string class.
Definition: String.h:58
OpenMS::HiddenMarkovModel::name_to_state_
Map< String, HMMState * > name_to_state_
Definition: HiddenMarkovModel.h:297
OpenMS::HMMState::succ_states_
std::set< HMMState * > succ_states_
Definition: HiddenMarkovModel.h:122
OpenMS::HMMState::name_
String name_
Definition: HiddenMarkovModel.h:116
OpenMS::HiddenMarkovModel::states_
std::set< HMMState * > states_
Definition: HiddenMarkovModel.h:306
Types.h
StringListUtils.h
OpenMS::HiddenMarkovModel::count_trans_
Map< HMMState *, Map< HMMState *, double > > count_trans_
Definition: HiddenMarkovModel.h:280
OpenMS::HiddenMarkovModel::count_trans_all_
Map< HMMState *, Map< HMMState *, std::vector< double > > > count_trans_all_
Definition: HiddenMarkovModel.h:282
OpenMS::HiddenMarkovModel::enabled_trans_
Map< HMMState *, std::set< HMMState * > > enabled_trans_
Definition: HiddenMarkovModel.h:318
OpenMS::HiddenMarkovModel::train_count_trans_all_
Map< HMMState *, Map< HMMState *, std::vector< double > > > train_count_trans_all_
Definition: HiddenMarkovModel.h:285
OpenMS::HiddenMarkovModel
Hidden Markov Model implementation of PILIS.
Definition: HiddenMarkovModel.h:133
OpenMS::HiddenMarkovModel::backward_
Map< HMMState *, double > backward_
Definition: HiddenMarkovModel.h:294
String.h
OpenMS::HiddenMarkovModel::init_prob_
Map< HMMState *, double > init_prob_
Definition: HiddenMarkovModel.h:303
OpenMS::Map
Map class based on the STL map (containing several convenience functions)
Definition: Map.h:50
OpenMS
Main OpenMS namespace.
Definition: FeatureDeconvolution.h:46
OpenMS::HMMState::pre_states_
std::set< HMMState * > pre_states_
Definition: HiddenMarkovModel.h:119
OpenMS::HMMState::hidden_
bool hidden_
Definition: HiddenMarkovModel.h:113
OpenMS::HiddenMarkovModel::train_emission_prob_
Map< HMMState *, double > train_emission_prob_
Definition: HiddenMarkovModel.h:300
Map.h
OpenMS::HMMState
Hidden Markov Model State class for the Hidden Markov Model.
Definition: HiddenMarkovModel.h:53
OpenMS::StringList
std::vector< String > StringList
Vector of String.
Definition: ListUtils.h:70
OpenMS::HiddenMarkovModel::var_modifications_
StringList var_modifications_
Definition: HiddenMarkovModel.h:326
OpenMS::HiddenMarkovModel::trained_trans_
std::set< std::pair< HMMState *, HMMState * > > trained_trans_
Definition: HiddenMarkovModel.h:309
OpenMS::HiddenMarkovModel::forward_
Map< HMMState *, double > forward_
Definition: HiddenMarkovModel.h:291
OpenMS::HiddenMarkovModel::synonym_trans_
Map< HMMState *, Map< HMMState *, std::pair< HMMState *, HMMState * > > > synonym_trans_
Definition: HiddenMarkovModel.h:315
OpenMS::HiddenMarkovModel::synonym_trans_names_
Map< String, Map< String, std::pair< String, String > > > synonym_trans_names_
Definition: HiddenMarkovModel.h:312
OpenMS::Size
size_t Size
Size type e.g. used as variable which can hold result of size()
Definition: Types.h:127
OpenMS::HiddenMarkovModel::pseudo_counts_
double pseudo_counts_
Definition: HiddenMarkovModel.h:321