blob: 21f2e09ab7ac49a17b38ca7c32ed58feccfb2e77 (
plain)
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
|
/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
/*
pYIN - A fundamental frequency estimator for monophonic audio
Centre for Digital Music, Queen Mary, University of London.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version. See the file
COPYING included with this distribution for more information.
*/
#include "SparseHMM.h"
#include <vector>
#include <cstdio>
#include <iostream>
using std::vector;
using std::pair;
const vector<double>
SparseHMM::calculateObsProb(const vector<pair<double, double> > data)
{
// dummy (virtual?) implementation to be overloaded
return(vector<double>());
}
const std::vector<int>
SparseHMM::decodeViterbi(std::vector<vector<double> > obsProb,
vector<double> *scale)
{
if (obsProb.size() < 1) {
return vector<int>();
}
size_t nState = init.size();
size_t nFrame = obsProb.size();
// check for consistency
size_t nTrans = transProb.size();
// declaring variables
std::vector<double> delta = std::vector<double>(nState);
std::vector<double> oldDelta = std::vector<double>(nState);
vector<vector<int> > psi; // "matrix" of remembered indices of the best transitions
vector<int> path = vector<int>(nFrame, nState-1); // the final output path (current assignment arbitrary, makes sense only for Chordino, where nChord-1 is the "no chord" label)
double deltasum = 0;
// initialise first frame
for (size_t iState = 0; iState < nState; ++iState)
{
oldDelta[iState] = init[iState] * obsProb[0][iState];
// std::cerr << iState << " ----- " << init[iState] << std::endl;
deltasum += oldDelta[iState];
}
for (size_t iState = 0; iState < nState; ++iState)
{
oldDelta[iState] /= deltasum; // normalise (scale)
// std::cerr << oldDelta[iState] << std::endl;
}
scale->push_back(1.0/deltasum);
psi.push_back(vector<int>(nState,0));
// rest of forward step
for (size_t iFrame = 1; iFrame < nFrame; ++iFrame)
{
deltasum = 0;
psi.push_back(vector<int>(nState,0));
// calculate best previous state for every current state
size_t fromState;
size_t toState;
double currentTransProb;
double currentValue;
// this is the "sparse" loop
for (size_t iTrans = 0; iTrans < nTrans; ++iTrans)
{
fromState = from[iTrans];
toState = to[iTrans];
currentTransProb = transProb[iTrans];
currentValue = oldDelta[fromState] * currentTransProb;
if (currentValue > delta[toState])
{
delta[toState] = currentValue; // will be multiplied by the right obs later!
psi[iFrame][toState] = fromState;
}
}
for (size_t jState = 0; jState < nState; ++jState)
{
delta[jState] *= obsProb[iFrame][jState];
deltasum += delta[jState];
}
if (deltasum > 0)
{
for (size_t iState = 0; iState < nState; ++iState)
{
oldDelta[iState] = delta[iState] / deltasum; // normalise (scale)
delta[iState] = 0;
}
scale->push_back(1.0/deltasum);
} else
{
std::cerr << "WARNING: Viterbi has been fed some zero probabilities, at least they become zero at frame " << iFrame << " in combination with the model." << std::endl;
for (size_t iState = 0; iState < nState; ++iState)
{
oldDelta[iState] = 1.0/nState;
delta[iState] = 0;
}
scale->push_back(1.0);
}
}
// initialise backward step
double bestValue = 0;
for (size_t iState = 0; iState < nState; ++iState)
{
double currentValue = oldDelta[iState];
if (currentValue > bestValue)
{
bestValue = currentValue;
path[nFrame-1] = iState;
}
}
// rest of backward step
for (int iFrame = nFrame-2; iFrame != -1; --iFrame)
{
path[iFrame] = psi[iFrame+1][path[iFrame+1]];
}
// for (size_t iState = 0; iState < nState; ++iState)
// {
// // std::cerr << psi[2][iState] << std::endl;
// }
return path;
}
|
