예제 #1
0
def recursionHelper(smooth, stateNum, states, viterbi, backpointer, wordTokens, t):
    smoothLater = True
    # v u s
    for s in range(stateNum):
        emissionEntry = states[s] + ' ' + wordTokens[t]
        if smooth and emissionEntry not in hmm.emissionP:
            emissionEntry = states[s] + ' ' + hmm.categorize(wordTokens[t])

        if emissionEntry not in hmm.emissionP:
            for u in range(stateNum):
                viterbi[u][s][t] = 0
        else:
            for u in range(stateNum):
                maxProb = 0
                maxProbIndex = 0

                for w in range(stateNum):
                    transEntry = states[w] + ' ' + states[u] + ' ' + states[s]
                    prob = interpolation(transEntry)

                    prob *= viterbi[w][u][t - 1]
                    if prob > maxProb:
                        maxProb = prob
                        maxProbIndex = w

                viterbi[u][s][t] = maxProb * hmm.emissionP[emissionEntry]
                backpointer[u][s][t] = maxProbIndex

            smoothLater = False

    return smoothLater
예제 #2
0
def recursionHelper(smooth, stateNum, states, viterbi, backpointer, wordTokens, t):
    smoothLater = True
    for s in range(stateNum):
        maxProb = 0
        maxProbIndex = 0
        for u in range(stateNum):
            transEntry = states[u] + ' ' + states[s]
            prob = 0
            if transEntry in hmm.biTransP:
                prob = viterbi[u][t - 1] * hmm.biTransP[transEntry]
            if prob > maxProb:
                maxProb = prob
                maxProbIndex = u

        emissionEntry = states[s] + ' ' + wordTokens[t]
        if smooth:
            if emissionEntry not in hmm.emissionP:
                emissionEntry = states[s] + ' ' + hmm.categorize(wordTokens[t])

        if emissionEntry not in hmm.emissionP:
            viterbi[s][t] = 0
        else:
            viterbi[s][t] = maxProb * hmm.emissionP[emissionEntry]
            smoothLater = False

        backpointer[s][t] = maxProbIndex

    return smoothLater
예제 #3
0
def initializationHelper(smooth, stateNum, states, viterbi, backpointer, wordTokens):
    smoothLater = True
    for s in range(stateNum):
        emissionEntry = states[s] + ' ' + wordTokens[0]
        if smooth:
            if emissionEntry not in hmm.emissionP:
                emissionEntry = states[s] + ' ' + hmm.categorize(wordTokens[0])

        if emissionEntry not in hmm.emissionP:
            viterbi[s][0] = 0
        else:
            transEntry = '<s> ' + states[s]
            if transEntry not in hmm.biTransP:
                viterbi[s][0] = 0
            else:
                viterbi[s][0] = hmm.biTransP[transEntry] * hmm.emissionP[emissionEntry]
                smoothLater = False
        backpointer[s][0] = 0

    return smoothLater
예제 #4
0
def secondInitializationHelper(smooth, stateNum, states, viterbi, backpointer, wordTokens):
    smoothLater = True
    # Second Time  -- * u s
    for s in range(stateNum):
        emissionEntry = states[s] + ' ' + wordTokens[1]
        if smooth and emissionEntry not in hmm.emissionP:
            emissionEntry = states[s] + ' ' + hmm.categorize(wordTokens[1])

        if emissionEntry not in hmm.emissionP:
            for u in range(stateNum):
                viterbi[u][s][1] = 0
        else:
            for u in range(stateNum):
                transEntry = '<s> ' + states[u] + ' ' + states[s]
                prob = interpolation(transEntry)

                viterbi[u][s][1] = viterbi[0][u][0] * \
                    prob * hmm.emissionP[emissionEntry]
                smoothLater = False

        for u in range(stateNum):
            backpointer[u][s][1] = -1

    return smoothLater
예제 #5
0
def firstInitializationHelper(smooth, stateNum, states, viterbi, backpointer, wordTokens):
    smoothLater = True
    # First time -- * * s
    for s in range(stateNum):
        emissionEntry = states[s] + ' ' + wordTokens[0]
        if smooth and emissionEntry not in hmm.emissionP:
            emissionEntry = states[s] + ' ' + hmm.categorize(wordTokens[0])

        if emissionEntry not in hmm.emissionP:
            for u in range(stateNum):
                viterbi[u][s][0] = 0
        else:
            transEntry = '<s> <s> ' + states[s]
            prob = interpolation(transEntry)
            prob *= hmm.emissionP[emissionEntry]

            for u in range(stateNum):
                viterbi[u][s][0] = prob
            smoothLater = False

        for u in range(stateNum):
            backpointer[u][s][0] = -1

    return smoothLater