def process(self, input_statement):
# Select the closest match to the input statement
closest_match = self.get(input_statement)
self.chatbot.logger.info('Using "{}" as a close match to "{}" with a confidence of {}'.format(
closest_match.text, input_statement.text, closest_match.confidence
))
recent_repeated_responses = filters.get_recent_repeated_responses(
self.chatbot,
input_statement.conversation
)
# Get all statements that are in response to the closest match
response_list = list(self.chatbot.storage.filter(
search_in_response_to=closest_match.search_text,
exclude_text=recent_repeated_responses,
exclude_text_words=self.excluded_words
))
if response_list:
self.chatbot.logger.info(
'Selecting response from {} optimal responses.'.format(
len(response_list)
)
)
response = self.select_response(
input_statement,
response_list,
self.chatbot.storage
)
response.confidence = closest_match.confidence
self.chatbot.logger.info('Response selected. Using "{}"'.format(response.text))
else:
response = self.chatbot.storage.get_random()
self.chatbot.logger.info(
'No response to "{}" found. Selecting a random response.'.format(
closest_match.text
)
)
# Set confidence to zero because a random response is selected
response.confidence = 0
return response
def process(self,
input_statement,
additional_response_selection_parameters=None):
search_results = self.search_algorithm.search(input_statement)
# Use the input statement as the closest match if no other results are found
closest_match = next(search_results, input_statement)
# Search for the closest match to the input statement
# Little modification to not stop even if threshold is respected
current_similarity = 0
for result in search_results:
# update
if result.confidence >= current_similarity:
closest_match = result
current_similarity = result.confidence
self.chatbot.logger.info(
'Using "{}" as a close match to "{}" with a confidence of {}'.
format(closest_match.text, input_statement.text,
closest_match.confidence))
recent_repeated_responses = filters.get_recent_repeated_responses(
self.chatbot, input_statement.conversation)
for index, recent_repeated_response in enumerate(
recent_repeated_responses):
self.chatbot.logger.info(
'{}. Excluding recent repeated response of "{}"'.format(
index, recent_repeated_response))
response_selection_parameters = {
'search_in_response_to': closest_match.search_text,
'exclude_text': recent_repeated_responses,
'exclude_text_words': self.excluded_words
}
alternate_response_selection_parameters = {
'search_in_response_to':
self.chatbot.storage.tagger.get_text_index_string(
input_statement.text),
'exclude_text':
recent_repeated_responses,
'exclude_text_words':
self.excluded_words
}
if additional_response_selection_parameters:
response_selection_parameters.update(
additional_response_selection_parameters)
alternate_response_selection_parameters.update(
additional_response_selection_parameters)
# Get all statements that are in response to the closest match
response_list = list(
self.chatbot.storage.filter(**response_selection_parameters))
alternate_response_list = []
if not response_list:
self.chatbot.logger.info(
'No responses found. Generating alternate response list.')
alternate_response_list = list(
self.chatbot.storage.filter(
**alternate_response_selection_parameters))
if response_list:
self.chatbot.logger.info(
'Selecting response from {} optimal responses.'.format(
len(response_list)))
# If the threshold wasn't respected before => but a bad answer
if (closest_match.confidence < self.maximum_similarity_threshold):
response.text = "<p>Désolé mais je n'ai pas compris la question :( Pourrais-tu la reformuler s'il te plait.</p><p> <div style='color:red;'>Attention !</div> Il faut savoir que je réponds aux questions liées à la programmation en générale, pas sur l'exercice.</p>"
response.confidence = closest_match.confidence
self.chatbot.logger.info('Response selected. Using "{}"'.format(
response.text))
elif alternate_response_list:
'''
The case where there was no responses returned for the selected match
but a value exists for the statement the match is in response to.
'''
self.chatbot.logger.info(
'Selecting response from {} optimal alternate responses.'.
format(len(alternate_response_list)))
response = self.select_response(input_statement,
alternate_response_list,
self.chatbot.storage)
response.confidence = closest_match.confidence
self.chatbot.logger.info(
'Alternate response selected. Using "{}"'.format(
response.text))
else:
response = self.get_default_response(input_statement)
return response
def process(self,
input_statement,
additional_response_selection_parameters=None):
search_results = self.search_algorithm.search(input_statement)
# Use the input statement as the closest match if no other results are found
closest_match = next(search_results, input_statement)
# Search for the closest match to the input statement
for result in search_results:
closest_match = result
# Stop searching if a match that is close enough is found
if result.confidence >= self.maximum_similarity_threshold:
closest_match = result
break
self.chatbot.logger.info(
'Using "{}" as a close match to "{}" with a confidence of {}'.
format(closest_match.text, input_statement.text,
closest_match.confidence))
recent_repeated_responses = filters.get_recent_repeated_responses(
self.chatbot, input_statement.conversation)
for index, recent_repeated_response in enumerate(
recent_repeated_responses):
self.chatbot.logger.info(
'{}. Excluding recent repeated response of "{}"'.format(
index, recent_repeated_response))
response_selection_parameters = {
'search_in_response_to': closest_match.search_text,
'exclude_text': recent_repeated_responses,
'exclude_text_words': self.excluded_words
}
alternate_response_selection_parameters = {
'search_in_response_to':
self.chatbot.storage.tagger.get_bigram_pair_string(
input_statement.text),
'exclude_text':
recent_repeated_responses,
'exclude_text_words':
self.excluded_words
}
if additional_response_selection_parameters:
response_selection_parameters.update(
additional_response_selection_parameters)
alternate_response_selection_parameters.update(
additional_response_selection_parameters)
# Get all statements that are in response to the closest match
response_list = list(
self.chatbot.storage.filter(**response_selection_parameters))
alternate_response_list = []
if not response_list:
self.chatbot.logger.info(
'No responses found. Generating alternate response list.')
alternate_response_list = list(
self.chatbot.storage.filter(
**alternate_response_selection_parameters))
if response_list:
self.chatbot.logger.info(
'Selecting response from {} optimal responses.'.format(
len(response_list)))
response = self.select_response(input_statement, response_list,
self.chatbot.storage)
response.confidence = closest_match.confidence
self.chatbot.logger.info('Response selected. Using "{}"'.format(
response.text))
elif alternate_response_list:
'''
The case where there was no responses returned for the selected match
but a value exists for the statement the match is in response to.
'''
self.chatbot.logger.info(
'Selecting response from {} optimal alternate responses.'.
format(len(alternate_response_list)))
response = self.select_response(input_statement,
alternate_response_list,
self.chatbot.storage)
response.confidence = closest_match.confidence
self.chatbot.logger.info(
'Alternate response selected. Using "{}"'.format(
response.text))
else:
response = self.get_default_response(input_statement)
return response
def process(self, input_statement, additional_response_selection_parameters=None):
search_results = self.search_algorithm.search(input_statement)
# Use the input statement as the closest match if no other results are found
closest_match = next(search_results, input_statement)
# Search for the closest match to the input statement
for result in search_results:
# Stop searching if a match that is close enough is found
if result.confidence >= self.maximum_similarity_threshold:
closest_match = result
break
self.chatbot.logger.info('Using "{}" as a close match to "{}" with a confidence of {}'.format(
closest_match.text, input_statement.text, closest_match.confidence
))
recent_repeated_responses = filters.get_recent_repeated_responses(
self.chatbot,
input_statement.conversation
)
for index, recent_repeated_response in enumerate(recent_repeated_responses):
self.chatbot.logger.info('{}. Excluding recent repeated response of "{}"'.format(
index, recent_repeated_response
))
response_selection_parameters = {
'search_in_response_to': closest_match.search_text,
'exclude_text': recent_repeated_responses,
'exclude_text_words': self.excluded_words
}
alternate_response_selection_parameters = {
'search_in_response_to': self.chatbot.storage.tagger.get_bigram_pair_string(
input_statement.text
),
'exclude_text': recent_repeated_responses,
'exclude_text_words': self.excluded_words
}
if additional_response_selection_parameters:
response_selection_parameters.update(additional_response_selection_parameters)
alternate_response_selection_parameters.update(additional_response_selection_parameters)
# Get all statements that are in response to the closest match
response_list = list(self.chatbot.storage.filter(**response_selection_parameters))
alternate_response_list = []
if not response_list:
self.chatbot.logger.info('No responses found. Generating alternate response list.')
alternate_response_list = list(self.chatbot.storage.filter(**alternate_response_selection_parameters))
if response_list:
self.chatbot.logger.info(
'Selecting response from {} optimal responses.'.format(
len(response_list)
)
)
response = self.select_response(
input_statement,
response_list,
self.chatbot.storage
)
response.confidence = closest_match.confidence
self.chatbot.logger.info('Response selected. Using "{}"'.format(response.text))
elif alternate_response_list:
'''
The case where there was no responses returned for the selected match
but a value exists for the statement the match is in response to.
'''
self.chatbot.logger.info(
'Selecting response from {} optimal alternate responses.'.format(
len(alternate_response_list)
)
)
response = self.select_response(
input_statement,
alternate_response_list,
self.chatbot.storage
)
response.confidence = closest_match.confidence
self.chatbot.logger.info('Alternate response selected. Using "{}"'.format(response.text))
else:
response = self.get_default_response(input_statement)
return response
def process(self,
input_statement,
additional_response_selection_parameters=None):
no_responses_found = True
search_results = self.search_algorithm.search(input_statement)
results_by_confidence = []
# input_statement is used as a last resort
results_by_confidence.append(input_statement)
nbr_of_results = 0
# get search results and sort by confidence
for result in search_results:
# add result to list, keep list sorted by confidence descending
for i in range(len(results_by_confidence)):
if result.confidence > results_by_confidence[i].confidence:
results_by_confidence.insert(i, result)
break
nbr_of_results = nbr_of_results + 1
if nbr_of_results >= MAX_RESULTS:
break
recent_repeated_responses = filters.get_recent_repeated_responses(
self.chatbot, input_statement.conversation)
for index, recent_repeated_response in enumerate(
recent_repeated_responses):
self.chatbot.logger.info(
'{}. Excluding recent repeated response of "{}"'.format(
index, recent_repeated_response))
# search for a response for results sorted by descending confidence
# not all results have a response
for closest_match in results_by_confidence:
self.chatbot.logger.info(
'Using "{}" as a close match to "{}" with a confidence of {}'.
format(closest_match.text, input_statement.text,
closest_match.confidence))
response_selection_parameters = {
'search_in_response_to': closest_match.search_text,
'exclude_text': recent_repeated_responses,
'exclude_text_words': self.excluded_words
}
if additional_response_selection_parameters:
response_selection_parameters.update(
additional_response_selection_parameters)
# get all statements that are in response to the closest match
response_list = list(
self.chatbot.storage.filter(**response_selection_parameters))
if not response_list:
self.chatbot.logger.info('No responses found, continuing.')
continue
if response_list:
self.chatbot.logger.info(
'Selecting response from {} optimal responses.'.format(
len(response_list)))
response = self.select_response(input_statement, response_list,
self.chatbot.storage)
response.confidence = closest_match.confidence
self.chatbot.logger.info(
'Response selected. Using "{}"'.format(response.text))
no_responses_found = False
break
# no responses found, try generating alternate response
if no_responses_found:
self.chatbot.logger.info(
'No responses found. Generating alternate response list.')
alternate_response_list = []
alternate_response_selection_parameters = {
'search_in_response_to':
self.chatbot.storage.tagger.get_bigram_pair_string(
input_statement.text),
'exclude_text':
recent_repeated_responses,
'exclude_text_words':
self.excluded_words
}
if additional_response_selection_parameters:
alternate_response_selection_parameters.update(
additional_response_selection_parameters)
alternate_response_list = list(
self.chatbot.storage.filter(
**alternate_response_selection_parameters))
if alternate_response_list:
self.chatbot.logger.info(
'Selecting response from {} optimal alternate responses.'.
format(len(alternate_response_list)))
response = self.select_response(input_statement,
alternate_response_list,
self.chatbot.storage)
# response.confidence = closest_match.confidence
self.chatbot.logger.info(
'Alternate response selected. Using "{}"'.format(
response.text))
no_responses_found = False
# no responses found, use default response
if no_responses_found:
response = self.get_default_response(input_statement)
return response
def process(self, input_statement, additional_response_selection_parameters=None):
search_results = self.search_algorithm.search(input_statement)
# Use the input statement as the closest match if no other results are found
closest_match = next(search_results, input_statement)
# Search for the closest match to the input statement
for result in search_results:
# Stop searching if a match that is close enough is found
if result.confidence >= self.maximum_similarity_threshold:
closest_match = result
break
recent_repeated_responses = filters.get_recent_repeated_responses(
self.chatbot,
input_statement.conversation
)
print('closest_match',closest_match)
print("self.maximum_similarity_threshold",self.maximum_similarity_threshold)
response_selection_parameters = {
'search_in_response_to': closest_match.text,
'exclude_text': recent_repeated_responses,
'exclude_text_words': self.excluded_words
}
alternate_response_selection_parameters = {
'search_in_response_to': self.chatbot.storage.tagger.get_bigram_pair_string(
input_statement.text
),
'exclude_text': recent_repeated_responses,
'exclude_text_words': self.excluded_words
}
if additional_response_selection_parameters:
response_selection_parameters.update(additional_response_selection_parameters)
alternate_response_selection_parameters.update(additional_response_selection_parameters)
# Get all statements that are in response to the closest match
response_list = list(self.chatbot.storage.filter(**response_selection_parameters))
print('response_list',response_list)
alternate_response_list = []
if not response_list:
self.chatbot.logger.info('No responses found. Generating alternate response list.')
alternate_response_list = list(self.chatbot.storage.filter(**alternate_response_selection_parameters))
if response_list:
self.chatbot.logger.info(
'Selecting response from {} optimal responses.'.format(
len(response_list)
)
)
count = len(response_list)
return_response=closest_match
largest_score=0
MIN_SCORE = 35
for response in response_list:
score = self.compare_statements(response,closest_match)
if score > largest_score and score > MIN_SCORE:
print(response.text,'=',score)
return_response=response
largest_score=score
print('return_response',return_response)
print('largest_score',largest_score)
if largest_score == 100.0:
self.chatbot.read_only = False
self.chatbot.learn_response(Statement(text=return_response.text), Statement(text=closest_match))
self.chatbot.read_only = True
if return_response:
response=return_response
#response = response_list[random.randint(0,count-1)]
'''response = self.select_response(
input_statement,
response_list,
self.chatbot.storage
)'''
response.confidence = closest_match.confidence
self.chatbot.logger.info('Response selected. Using "{}"'.format(response.text))
elif alternate_response_list:
print('alternate_response_list',alternate_response_list)
'''
The case where there was no responses returned for the selected match
but a value exists for the statement the match is in response to.
'''
self.chatbot.logger.info(
'Selecting response from {} optimal alternate responses.'.format(
len(alternate_response_list)
)
)
response = self.select_response(
input_statement,
alternate_response_list,
self.chatbot.storage
)
response.confidence = closest_match.confidence
self.chatbot.logger.info('Alternate response selected. Using "{}"'.format(response.text))
else:
print('returning default response')
response = self.get_default_response(input_statement)
return response
