def getProbability(self, X, Y, x, y, dx, dy, positionGenerator = None):
table = self.getForwardTable(X, Y, x, y, dx, dy,
memoryPattern=MemoryPatterns.last(dx),
positionGenerator=positionGenerator)
r = self.getTable(X, x, dx, Y, y, dy, [self.probabilityResult],
table, [], positionGenerator) #TODO tu som robil zmenu
return r[0]
def getViterbiTable(self, X, x, dx, memoryPattern=None, initialRow=None):
if memoryPattern == None:
memoryPattern = MemoryPatterns.every(dx + 1)
#TODO: pridaj jednu vrstvu dictov, aby to fungovalo (lebo inac
#pri initi stave/silent stavoch pises do dictu cez ktory sa iteruje
#a zaroven to chces aj pouzit
#pri odovzdavani by sa to mozno ale patrilo spojit
# v skutocnomsti to nebude treba. Idealny stav je, ze vyrobime specialny
# init stav, ktory pojde do ostatnych stavov
rows = [[
defaultdict(lambda *x: (self.mathType(0.0), -1))
for _ in range(len(self.states))
] for _ in range(dx + 1)]
#zacinam v 0 riadku
ignoreFirstRow = False
if initialRow != None:
rows[0] = initialRow
ignoreFirstRow = True
else:
for state in self.states:
prob = state.getStartProbability()
if prob > self.mathType(0.0):
rows[0][state.getStateID()][0] = (prob, -1)
# Main algorithm
retTable = list()
for _x in range(dx + 1):
if ignoreFirstRow and _x == 0:
continue
for stateID in range(len(self.states)):
acc_prob = reduce(
max,
[value[0] for (_, value) in rows[_x][stateID].iteritems()],
self.mathType(0.0))
state = self.states[stateID]
for (followingID, transprob) in state.followingIDs():
following = self.states[followingID]
acc_trans_prob = acc_prob * transprob
for (_sdx, dprob) in following.durationGenerator():
if _x + _sdx > dx:
continue
rows[_x + _sdx][followingID][_sdx] = max (
rows[_x + _sdx][followingID][_sdx],
(
following.emission(X, x + _x, _sdx) \
* acc_trans_prob * dprob,
stateID,
),
key = lambda x: x[0],
)
if _x < 0:
continue
if memoryPattern.next():
retTable.append((_x, rows[_x]))
rows[_x] = list()
return retTable
def getViterbiTable(self, X, x, dx, memoryPattern=None, initialRow=None):
if memoryPattern == None:
memoryPattern = MemoryPatterns.every(dx + 1)
#TODO: pridaj jednu vrstvu dictov, aby to fungovalo (lebo inac
#pri initi stave/silent stavoch pises do dictu cez ktory sa iteruje
#a zaroven to chces aj pouzit
#pri odovzdavani by sa to mozno ale patrilo spojit
# v skutocnomsti to nebude treba. Idealny stav je, ze vyrobime specialny
# init stav, ktory pojde do ostatnych stavov
rows = [[defaultdict(lambda *x: (self.mathType(0.0), -1))
for _ in range(len(self.states))]
for _ in range(dx + 1)]
#zacinam v 0 riadku
ignoreFirstRow = False
if initialRow != None:
rows[0] = initialRow
ignoreFirstRow = True
else:
for state in self.states:
prob = state.getStartProbability()
if prob > self.mathType(0.0):
rows[0][state.getStateID()][0] = (prob, -1)
# Main algorithm
retTable = list()
for _x in range(dx + 1):
if ignoreFirstRow and _x == 0:
continue
for stateID in range(len(self.states)):
acc_prob = reduce(max,
[value[0] for (_,value) in
rows[_x][stateID].iteritems()],
self.mathType(0.0))
state = self.states[stateID]
for (followingID, transprob) in state.followingIDs():
following = self.states[followingID]
acc_trans_prob = acc_prob * transprob
for (_sdx, dprob) in following.durationGenerator():
if _x + _sdx > dx:
continue
rows[_x + _sdx][followingID][_sdx] = max (
rows[_x + _sdx][followingID][_sdx],
(
following.emission(X, x + _x, _sdx) \
* acc_trans_prob * dprob,
stateID,
),
key = lambda x: x[0],
)
if _x < 0:
continue
if memoryPattern.next():
retTable.append((_x, rows[_x]))
rows[_x] = list()
return retTable
def getProbability(self, X, x, dx, positionGenerator=None, table=None):
if table == None:
table = self.getForwardTable(
X, x, dx, memoryPattern=MemoryPatterns.last(dx + 1))
return sum([self.mathType(sum([prob for (_, prob) in dct.iteritems()]))
* self.states[stateID].getEndProbability()
for (stateID, dct) in ((l, table[0][1][l])
for l in range(len(table[0][1])))])
def getProbability(self, X, Y, x, y, dx, dy, positionGenerator=None):
table = self.getForwardTable(X,
Y,
x,
y,
dx,
dy,
memoryPattern=MemoryPatterns.last(dx),
positionGenerator=positionGenerator)
r = self.getTable(X, x, dx, Y, y, dy, [self.probabilityResult], table,
[], positionGenerator) #TODO tu som robil zmenu
return r[0]
def getProbabilities(self, X, x, dx, positionGenerator=None, table=None):
if table == None:
table = self.getForwardTable(
X, x, dx, memoryPattern=MemoryPatterns.every(dx + 1))
return [
sum([
self.mathType(sum([prob for (_, prob) in dct.iteritems()])) *
self.states[stateID].getEndProbability()
for (stateID, dct) in ((l, row[1][l])
for l in range(len(row[1])))
]) for row in table
]
def getBackwardTable(self, X, x, dx, memoryPattern=None, initialRow=None):
if memoryPattern == None:
memoryPattern = MemoryPatterns.every(dx + 1)
rows = [[self.mathType(0.0)
for _ in range(len(self.states))]
for _ in range(dx+1)]
ignoreFirstRow = False
if initialRow != None:
rows[dx] = initialRow
ignoreFirstRow = True
else:
for state in self.states:
prob = state.getEndProbability()
if prob > self.mathType(0.0):
rows[dx][state.getStateID()] = prob
# Main algorithm
retTable = list()
for _x in reversed(list(range(dx + 1))):
if ignoreFirstRow and _x == dx:
continue
for stateID in range(len(self.states)):
state = self.states[stateID]
for (previousID, transprob) in state.previousIDs():
previous = self.states[previousID]
acc_trans_prob = rows[_x][stateID] * transprob
for (_sdx, dprob) in previous.durationGenerator():
if _x-_sdx < 0:
continue
rows[_x - _sdx][previousID] += \
previous.emission(X, x + _x - _sdx, _sdx) \
* acc_trans_prob * dprob
if _x>dx:
continue
if memoryPattern.next():
retTable.append((_x, rows[_x]))
rows[_x] = list()
return retTable
def getBackwardTable(self, X, x, dx, memoryPattern=None, initialRow=None):
if memoryPattern == None:
memoryPattern = MemoryPatterns.every(dx + 1)
rows = [[self.mathType(0.0) for _ in range(len(self.states))]
for _ in range(dx + 1)]
ignoreFirstRow = False
if initialRow != None:
rows[dx] = initialRow
ignoreFirstRow = True
else:
for state in self.states:
prob = state.getEndProbability()
if prob > self.mathType(0.0):
rows[dx][state.getStateID()] = prob
# Main algorithm
retTable = list()
for _x in reversed(list(range(dx + 1))):
if ignoreFirstRow and _x == dx:
continue
for stateID in range(len(self.states)):
state = self.states[stateID]
for (previousID, transprob) in state.previousIDs():
previous = self.states[previousID]
acc_trans_prob = rows[_x][stateID] * transprob
for (_sdx, dprob) in previous.durationGenerator():
if _x - _sdx < 0:
continue
rows[_x - _sdx][previousID] += \
previous.emission(X, x + _x - _sdx, _sdx) \
* acc_trans_prob * dprob
if _x > dx:
continue
if memoryPattern.next():
retTable.append((_x, rows[_x]))
rows[_x] = list()
return retTable
def getViterbiTable(self, X, x, dx, Y, y, dy,
memoryPattern=None, positionGenerator=None,
initialRow=None):
# NOTICE: toto je len skopirovane z forward Table a upravene
# Toto by malo byt rovnake ako pred tym
# Default position generator
if positionGenerator == None:
positionGenerator = \
((i, j) for i in range(dx + 1) for j in range(dy + 1))
# Default memory pattern (everything)
if memoryPattern == None:
memoryPattern = MemoryPatterns.every(dx + 1)
# Initialize table
rows = [
defaultdict(
lambda *_: [defaultdict(
lambda *_:
(
self.mathType(0.0),
-1
)
) for _ in range(len(self.states))
]
)
for _ in range(dx + 1)
]
# Initialize first row
ignoreFirstRow = False
if initialRow != None:
rows[0] = initialRow
ignoreFirstRow = True
else:
for state in self.states:
rows[0][0][state.getStateID()][(0, 0)] = \
(state.getStartProbability(), -1)
# Main algorithm
_x_prev = -1000000
retTable = list()
# Position generator zaruci ze nebudem mat problem menenim
# dictionary za jazdy. Problem to vyraba ak sa vyraba novy stav.
for (_x, _y) in positionGenerator:
if ignoreFirstRow and _x == 0:
continue
for stateID in range(len(self.states)):
acc_prob = reduce(max,
[value[0] for (_, value) in
rows[_x][_y][stateID].iteritems()],
self.mathType(0.0))
state = self.states[stateID]
if acc_prob <= self.mathType(0.0):
continue
for (followingID, transprob) in state.followingIDs():
following = self.states[followingID]
for ((_sdx, _sdy), dprob) in \
following.durationGenerator(_x, _y):
if _x + _sdx > dx or _y + _sdy > dy or _x + _sdx < 0 or _y + _sdy < 0:
continue
#dprob = self.mathType(1.0)
rows[_x + _sdx][_y + _sdy][followingID][(_sdx, _sdy)] \
= max(
rows[_x + _sdx][_y + _sdy][followingID][(_sdx, _sdy)],
(
acc_prob * transprob * dprob * \
following.emission(
X,
x + _x,
_sdx,
Y,
y + _y,
_sdy
),
stateID
),
key=lambda x: x[0]
)
# If rows were changed, remember it
if _x_prev != _x:
if _x_prev >= 0 and _x_prev <= dx:
if memoryPattern.next():
retTable.append((x + _x_prev, rows[_x_prev]))
rows[_x_prev] = list()
_x_prev = _x
# Remember last row if necessary
if memoryPattern.next():
retTable.append((x + _x_prev, rows[dx]))
# Finally, done:-)
ret = [dict() for _ in range(dx + 1)]
for i, _x in retTable:
ret[i - x] = _x
return ret
def getBackwardTable(self, X, x, dx, Y, y, dy,
memoryPattern=None, positionGenerator=None,
initialRow=None):
# Default position generator
if positionGenerator == None:
positionGenerator = \
((i, j) for i in range(dx + 1) for j in range(dy + 1))
# Some generators have to be reversed
positionGenerator = list(reversed(list(positionGenerator)))
# Default memory pattern (everything)
if memoryPattern == None:
memoryPattern = MemoryPatterns.every(dx + 1)
# Initialize table
rows = [defaultdict(
lambda *_: [self.mathType(0.0)
for _ in range(len(self.states))])
for _ in range(dx + 1)]
# Initialize first row
ignoreFirstRow = False
if initialRow != None:
rows[dx] = initialRow
ignoreFirstRow = True
else:
for state in self.states:
rows[dx][dy][state.getStateID()] = \
state.getEndProbability()
# Main algorithm
_x_prev = x + dx + 100000
retTable = list()
states = list(reversed(range(len(self.states))))
for (_x, _y) in positionGenerator:
if ignoreFirstRow and _x == dx:
continue
for stateID in states:
acc_prob = rows[_x][_y][stateID]
state = self.states[stateID]
if acc_prob <= self.mathType(0.0):
continue
for (previousID, transprob) in state.previousIDs():
previous = self.states[previousID]
for ((_sdx, _sdy), dprob) in \
previous.reverseDurationGenerator(_x, _y):
if _x - _sdx < 0 or _y - _sdy < 0 or _x - _sdx > dx or _y - _sdy > dy:
continue
rows[_x - _sdx][_y - _sdy][previousID] += (
acc_prob * transprob * dprob *
previous.emission(
X,
x + _x - _sdx,
_sdx,
Y,
x + _y - _sdy,
_sdy
)
)
# Remember last row if necessary
if _x_prev != _x:
if _x_prev >= 0 and _x_prev <= dx:
if memoryPattern.next():
retTable.append((x + _x_prev, rows[_x_prev]))
rows[_x_prev] = list()
_x_prev = _x
# Remember last row if necessary
if memoryPattern.next():
retTable.append((x + _x_prev, rows[0]))
# Finally, done:-)
return retTable
def getForwardTableGenerator(self, X, x, dx, Y, y, dy,
memoryPattern=None, positionGenerator=None, initialRow=None):
# Default position generator
if positionGenerator == None:
positionGenerator = \
((i, j) for i in range(dx + 1) for j in range(dy + 1))
# Default memory pattern (everything)
if memoryPattern == None:
memoryPattern = MemoryPatterns.every(dx + 1)
# Initialize table
rows = [defaultdict(
lambda *_: [defaultdict(self.mathType)
for _ in range(len(self.states))])
for _ in range(dx + 1)]
# Initialize first row
ignoreFirstRow = False
if initialRow != None:
rows[0] = initialRow
ignoreFirstRow = True
else:
for state in self.states:
rows[0][0][state.getStateID()][(0, 0)] = \
state.getStartProbability()
# Main algorithm
_x_prev = -1000000
# Position generator zaruci ze nebudem mat problem menenim
# dictionary za jazdy. Problem to vyraba ak sa vyraba novy stav.
for (_x, _y) in positionGenerator:
if ignoreFirstRow and _x == 0: #FIXME: ak ignorujem prvy riadok, pokazi sa mi zapamatavanie
continue
for stateID in range(len(self.states)):
acc_prob = reduce(operator.add,
[value for (_, value) in
rows[_x][_y][stateID].iteritems()],
self.mathType(0.0))
state = self.states[stateID]
if acc_prob <= self.mathType(0.0):
continue
for (followingID, transprob) in state.followingIDs():
following = self.states[followingID]
for ((_sdx, _sdy), dprob) in \
following.durationGenerator(_x, _y):
if _x + _sdx > dx or _y + _sdy > dy:
continue
rows[_x + _sdx][_y + _sdy][followingID][(_sdx, _sdy)] \
+= acc_prob * transprob * dprob * \
following.emission(
X,
x + _x,
_sdx,
Y,
y + _y,
_sdy
)
# If rows were changed, remember it
if _x_prev != _x:
if _x_prev >= 0 and _x_prev <= dx:
if memoryPattern.next():
yield x + _x_prev, rows[_x_prev]
rows[_x_prev] = list()
_x_prev = _x
# Remember last row if necessary
if memoryPattern.next():
yield x + _x_prev, rows[dx]
def getViterbiTable(self,
X,
x,
dx,
Y,
y,
dy,
memoryPattern=None,
positionGenerator=None,
initialRow=None):
# NOTICE: toto je len skopirovane z forward Table a upravene
# Toto by malo byt rovnake ako pred tym
# Default position generator
if positionGenerator == None:
positionGenerator = \
((i, j) for i in range(dx + 1) for j in range(dy + 1))
# Default memory pattern (everything)
if memoryPattern == None:
memoryPattern = MemoryPatterns.every(dx + 1)
# Initialize table
rows = [
defaultdict(lambda *_: [
defaultdict(lambda *_: (self.mathType(0.0), -1))
for _ in range(len(self.states))
]) for _ in range(dx + 1)
]
# Initialize first row
ignoreFirstRow = False
if initialRow != None:
rows[0] = initialRow
ignoreFirstRow = True
else:
for state in self.states:
rows[0][0][state.getStateID()][(0, 0)] = \
(state.getStartProbability(), -1)
# Main algorithm
_x_prev = -1000000
retTable = list()
# Position generator zaruci ze nebudem mat problem menenim
# dictionary za jazdy. Problem to vyraba ak sa vyraba novy stav.
for (_x, _y) in positionGenerator:
if ignoreFirstRow and _x == 0:
continue
for stateID in range(len(self.states)):
acc_prob = reduce(max, [
value[0]
for (_, value) in rows[_x][_y][stateID].iteritems()
], self.mathType(0.0))
state = self.states[stateID]
if acc_prob <= self.mathType(0.0):
continue
for (followingID, transprob) in state.followingIDs():
following = self.states[followingID]
for ((_sdx, _sdy), dprob) in \
following.durationGenerator(_x, _y):
if _x + _sdx > dx or _y + _sdy > dy or _x + _sdx < 0 or _y + _sdy < 0:
continue
#dprob = self.mathType(1.0)
rows[_x + _sdx][_y + _sdy][followingID][(_sdx, _sdy)] \
= max(
rows[_x + _sdx][_y + _sdy][followingID][(_sdx, _sdy)],
(
acc_prob * transprob * dprob * \
following.emission(
X,
x + _x,
_sdx,
Y,
y + _y,
_sdy
),
stateID
),
key=lambda x: x[0]
)
# If rows were changed, remember it
if _x_prev != _x:
if _x_prev >= 0 and _x_prev <= dx:
if memoryPattern.next():
retTable.append((x + _x_prev, rows[_x_prev]))
rows[_x_prev] = list()
_x_prev = _x
# Remember last row if necessary
if memoryPattern.next():
retTable.append((x + _x_prev, rows[dx]))
# Finally, done:-)
ret = [dict() for _ in range(dx + 1)]
for i, _x in retTable:
ret[i - x] = _x
return ret
def getBackwardTable(self,
X,
x,
dx,
Y,
y,
dy,
memoryPattern=None,
positionGenerator=None,
initialRow=None):
# Default position generator
if positionGenerator == None:
positionGenerator = \
((i, j) for i in range(dx + 1) for j in range(dy + 1))
# Some generators have to be reversed
positionGenerator = list(reversed(list(positionGenerator)))
# Default memory pattern (everything)
if memoryPattern == None:
memoryPattern = MemoryPatterns.every(dx + 1)
# Initialize table
rows = [
defaultdict(lambda *_:
[self.mathType(0.0) for _ in range(len(self.states))])
for _ in range(dx + 1)
]
# Initialize first row
ignoreFirstRow = False
if initialRow != None:
rows[dx] = initialRow
ignoreFirstRow = True
else:
for state in self.states:
rows[dx][dy][state.getStateID()] = \
state.getEndProbability()
# Main algorithm
_x_prev = x + dx + 100000
retTable = list()
states = list(reversed(range(len(self.states))))
for (_x, _y) in positionGenerator:
if ignoreFirstRow and _x == dx:
continue
for stateID in states:
acc_prob = rows[_x][_y][stateID]
state = self.states[stateID]
if acc_prob <= self.mathType(0.0):
continue
for (previousID, transprob) in state.previousIDs():
previous = self.states[previousID]
for ((_sdx, _sdy), dprob) in \
previous.reverseDurationGenerator(_x, _y):
if _x - _sdx < 0 or _y - _sdy < 0 or _x - _sdx > dx or _y - _sdy > dy:
continue
rows[_x - _sdx][_y - _sdy][previousID] += (
acc_prob * transprob * dprob *
previous.emission(X, x + _x - _sdx, _sdx, Y,
x + _y - _sdy, _sdy))
# Remember last row if necessary
if _x_prev != _x:
if _x_prev >= 0 and _x_prev <= dx:
if memoryPattern.next():
retTable.append((x + _x_prev, rows[_x_prev]))
rows[_x_prev] = list()
_x_prev = _x
# Remember last row if necessary
if memoryPattern.next():
retTable.append((x + _x_prev, rows[0]))
# Finally, done:-)
return retTable
def getForwardTableGenerator(self,
X,
x,
dx,
Y,
y,
dy,
memoryPattern=None,
positionGenerator=None,
initialRow=None):
# Default position generator
if positionGenerator == None:
positionGenerator = \
((i, j) for i in range(dx + 1) for j in range(dy + 1))
# Default memory pattern (everything)
if memoryPattern == None:
memoryPattern = MemoryPatterns.every(dx + 1)
# Initialize table
rows = [
defaultdict(
lambda *_:
[defaultdict(self.mathType) for _ in range(len(self.states))])
for _ in range(dx + 1)
]
# Initialize first row
ignoreFirstRow = False
if initialRow != None:
rows[0] = initialRow
ignoreFirstRow = True
else:
for state in self.states:
rows[0][0][state.getStateID()][(0, 0)] = \
state.getStartProbability()
# Main algorithm
_x_prev = -1000000
# Position generator zaruci ze nebudem mat problem menenim
# dictionary za jazdy. Problem to vyraba ak sa vyraba novy stav.
for (_x, _y) in positionGenerator:
if ignoreFirstRow and _x == 0: #FIXME: ak ignorujem prvy riadok, pokazi sa mi zapamatavanie
continue
for stateID in range(len(self.states)):
acc_prob = reduce(operator.add, [
value for (_, value) in rows[_x][_y][stateID].iteritems()
], self.mathType(0.0))
state = self.states[stateID]
if acc_prob <= self.mathType(0.0):
continue
for (followingID, transprob) in state.followingIDs():
following = self.states[followingID]
for ((_sdx, _sdy), dprob) in \
following.durationGenerator(_x, _y):
if _x + _sdx > dx or _y + _sdy > dy:
continue
rows[_x + _sdx][_y + _sdy][followingID][(_sdx, _sdy)] \
+= acc_prob * transprob * dprob * \
following.emission(
X,
x + _x,
_sdx,
Y,
y + _y,
_sdy
)
# If rows were changed, remember it
if _x_prev != _x:
if _x_prev >= 0 and _x_prev <= dx:
if memoryPattern.next():
yield x + _x_prev, rows[_x_prev]
rows[_x_prev] = list()
_x_prev = _x
# Remember last row if necessary
if memoryPattern.next():
yield x + _x_prev, rows[dx]
