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 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 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]