def insertVowels(queryWords, bigramCost, possibleFills):
# BEGIN_YOUR_CODE
'''
Implementação da função que faz a inserção de vogais.
Nessa implementação, o node.state é uma lista de strings que não possuem
vogais, a não ser pelo primeiro elemento da lista, este, representa a
ultima palavra que foi escolhida, já com as vogais. Além disso, o
node.action representa a palavra que foi escolhida naquele passo.
Logo, temos que initial_node.state == (<BEGIN> + query words) e
initial_node.action = "", além disso, temos que
goal_node.state == goal_node.action == <ultima palavra gerada>.
Assim, temos:
state => action and new_state
e para calcular o custo, basta pegarmos bigramCost(state[0], action).
'''
insert_problem = VowelInsertionProblem(queryWords, bigramCost,
possibleFills)
goal_node = util.uniformCostSearch(insert_problem)
if (goal_node != None):
is_valid, solution = util.getSolution(goal_node, insert_problem)
if (is_valid):
return solution
else:
print("Could not recover solution for the insert vowels problem")
return None
else:
print("Could not complete search for the insert vowels problem")
return None
def segmentWords(query, unigramCost):
if len(query) == 0:
return ''
problem = SegmentationProblem(query, unigramCost)
goal_node = util.uniformCostSearch(problem)
valid, solution = util.getSolution(goal_node, problem)
print('Query:{}, Solução:{} valida?{} goal_node:{}'.format(
query, solution, valid, goal_node.state))
return goal_node.state
def insertVowels(queryWords, bigramCost, possibleFills):
# BEGIN_YOUR_CODE
# Voce pode usar a função getSolution para recuperar a sua solução
# a partir do no meta
problem = VowelInsertionProblem(queryWords, bigramCost, possibleFills)
goalNode = util.uniformCostSearch(problem)
valid, solution = util.getSolution(goalNode, problem)
if valid:
return goalNode.state
def insertVowels(queryWords, bigramCost, possibleFills):
# BEGIN_YOUR_CODE
# Voce pode usar a função getSolution para recuperar a sua solução a partir do no meta
# valid,solution = util.getSolution(goalNode,problem)
# raise NotImplementedError
problem = VowelInsertionProblem(queryWords, bigramCost, possibleFills)
goal = util.uniformCostSearch(problem)
valid, solution = util.getSolution(goal, problem)
if valid:
return goal.state
return result
def segmentWords(query, unigramCost):
if len(query) == 0:
return ''
else:
# BEGIN_YOUR_CODE
# Voce pode usar a função getSolution para recuperar a sua solução a partir do no meta
# valid,solution = util.getSolution(goalNode,problem)
# raise NotImplementedError
problem = SegmentationProblem(query, unigramCost)
goal = util.uniformCostSearch(problem)
valid, solution = util.getSolution(goal, problem)
return solution
def segmentWords(query, unigramCost):
if len(query) == 0:
return ''
# BEGIN_YOUR_CODE
# Voce pode usar a função getSolution para recuperar a sua solução a partir do no meta
# valid,solution = util.getSolution(goalNode,problem)
segProb = SegmentationProblem(query, unigramCost)
segSol = util.uniformCostSearch(segProb)
segBool, segStr = util.getSolution(segSol, segProb)
return segStr + " " + segSol.state
def segmentWords(query, unigramCost):
if len(query) == 0:
return ''
# BEGIN_YOUR_CODE
# Voce pode usar a função getSolution para recuperar a sua solução
# a partir do no meta
problem = SegmentationProblem(query, unigramCost)
goalNode = util.uniformCostSearch(problem)
valid, solution = util.getSolution(goalNode, problem)
if valid:
result = goalNode.state
return solution
def segmentWords(query, unigramCost):
if len(query) == 0:
return ''
# BEGIN_YOUR_CODE
# Voce pode usar a função getSolution para recuperar a sua solução a partir do no meta
# valid,solution = util.getSolution(goalNode,problem)
problem = SegmentationProblem(query, unigramCost)
goal = util.uniformCostSearch(problem)
valid, solution = util.getSolution(goal, problem)
words = []
if valid:
actions = [0] + [int(a) for a in solution.strip(' ').split(' ')]
for i in range(0, len(actions) - 1):
word = query[actions[i]:actions[i + 1]]
words.append(word)
return ' '.join(words)
return None
def segmentWords(query, unigramCost):
if len(query) == 0:
return ''
# BEGIN_YOUR_CODE
'''
Implementação da função que faz a seguimentação de palavras.
Nessa implementação, o campo node.action vai conter a ultima palavra
originada, e o campo node.state representa o restante da string, parte
que ainda não foi dividida. Logo, temos que initial_node.action == ""
e que initial_node.state == query, além disso, temos que
goal_node.state == "" e que
goal_node.action == <utlima palavra da frase gerada>.
Ademais, nossa transição de estado é feita colocando um espaço em todas
as posições possiveis dentro da string que representa a estado, e a
partir disso, criamos a divisão:
<state> => <action> + <new_state>
onde, para calcularmos o custo, basta pegarmos unigramCost(action).
'''
segmentation_problem = SegmentationProblem(query, unigramCost)
goal_node = util.uniformCostSearch(segmentation_problem)
if (goal_node != None):
is_valid, solution = util.getSolution(goal_node, segmentation_problem)
if (is_valid):
return solution
else:
print("Could not recover solution for the segmentation problem")
return None
else:
print("Could not complete search for the segmentation problem")
return None
def segmentWords(query, unigramCost):
if len(query) == 0:
return ''
# BEGIN_YOUR_CODE
# Voce pode usar a função getSolution para recuperar a sua solução a partir do no meta
# valid,solution = util.getSolution(goalNode,problem)
problem = SegmentationProblem(query, unigramCost)
goalNode = util.uniformCostSearch(problem)
valid, solution = util.getSolution(goalNode, problem)
if valid:
solution = solution.split(' ')
answer = ""
prev = 0
for index in solution:
cut = int(index)
answer += query[prev:cut] + " "
prev = cut
return answer[:-1]
return None