def __init__(self):
# 提前加载各种模型
self.classify = Classify()
self.recall = Recall()
self.sort = DnnSort()
self.chatbot = Chatbot()
self.message_manager = MessageManager()
def run(self):
for server_name in config.sections():
# Changing the log level to the level specified in the config file
logger.setLevel(
logging.getLevelName(config[server_name]["log_level"]))
address = config[server_name]["address"]
user = config[server_name]["username"]
password = config[server_name]["password"]
game_password = config[server_name]["game_password"]
motd_scoreboard = str_to_bool(
config[server_name]["motd_scoreboard"])
scoreboard_type = config[server_name]["scoreboard_type"]
level_threshhold = config[server_name]["level_threshhold"]
enable_greeter = str_to_bool(config[server_name]["enable_greeter"])
max_players = config[server_name]["max_players"]
server = Server(server_name, address, user, password,
game_password, max_players, level_threshhold)
self.servers.append(server)
if motd_scoreboard:
motd_updater = MotdUpdater(server, scoreboard_type)
motd_updater.start()
self.motd_updaters.append(motd_updater)
cb = Chatbot(server, greeter_enabled=enable_greeter)
server.chat.add_listener(cb)
self.chatbots.append(cb)
print("Initialisation complete")
def _load_model(self):
model_path = os.path.join(DEEPQA_PATH, 'save')
saved_models = os.listdir(model_path)
saved_models = [
saved_model.replace("model-", "") for saved_model in saved_models
if not saved_model.startswith(".")
and os.path.isdir(os.path.join(model_path, saved_model))
]
self._logger.info('TensorFlow detected: v{}'.format(tf.__version__))
for saved_model in saved_models:
self._logger.info("loading model {}".format(saved_model))
model = Chatbot()
try:
self._init_deep_qa_bot(model,
args=[
"--modelTag", saved_model,
"--keepAll", "--test", "daemon",
"--rootDir", DEEPQA_PATH
])
self._deepqa_models.append(model)
if self._max_length > model.args.maxLength:
self._max_length = model.args.maxLength
except Exception as e:
self._logger.warning(
"failed to load model {}".format(saved_model))
self._logger.error(e)
self._logger.info("loaded model {}".format(
[model.args.modelTag for model in self._deepqa_models]))
def load_chatbot(self, user_id):
self.chatbot_instance_path = chatbot_instance_dir_path + '/' + str(
user_id)
self.chatbot_instance_path += '.cbinstance'
self.chatbot = Chatbot()
self.chatbot.load(self.chatbot_instance_path)
def start_chatbot():
print("Starting the chatbot")
chatbot_resource_filename = "wechat_chatbot_resource.json"
local_chatbot = Chatbot()
local_chatbot.start_bot(
chatbot_resource_filename,
backend_read=False) # Turn off backend read cuz no SQL to read
return local_chatbot
def get_chatbot():
lemmatizer = Lemmatizer()
text_processor = TextProcessor(
tokenizer,
stemmer,
joblib.load(config['vectorizer']),
lemmatizer,
Parser.get_instance(),
tagged_words_corpus)
phrase_extractor = PhraseExtractor(text_processor)
svo_extractor = SvoExtractor(text_processor, phrase_extractor)
sentence_scorer = SentenceScorer(text_processor, phrase_extractor)
entity_extractor = EntityExtractor(text_processor)
topic_classifier = TopicClassifierLocal(text_processor)
'''
summarizer = Summarizer(
text_processor,
sentence_scorer
)
'''
'''
summarizer = HttpSummarizer(
text_processor,
sentence_scorer,
summarization_service)
'''
summarizer = MultiProcessSummarizer(
text_processor,
sentence_scorer,
SummarizationTask,
Consumer)
data_manager = DataManager(
text_processor,
neo4j_service,
wikipedia_service,
Parser.get_instance(),
svo_extractor,
summarizer)
chatbot = Chatbot(
text_processor,
topic_classifier,
data_manager,
entity_extractor)
return chatbot
def initBot():
""" Instantiate the chatbot for later use
Should be called only once
"""
if not ChatbotManager.bot:
logger.info('Initializing bot...')
ChatbotManager.bot = Chatbot() #chatbot.Chatbot()
# need to find the chatbotPath for model and data
ChatbotManager.bot.main(
['--modelTag', 'server', '--test', 'daemon', '--rootDir', ''])
else:
logger.info('Bot already initialized.')
def make_chatbot(self, name, server):
chatbot = Chatbot(
server.web_admin.chat,
server_name=server.name, name=name
)
scheduler = CommandScheduler(server, chatbot)
commands = CommandMap().get_commands(
server, chatbot, scheduler, MotdUpdater(server)
)
for name, command in commands.items():
chatbot.add_command(name, command)
server.web_admin.chat.add_listener(chatbot)
server.web_admin.chat.add_listener(scheduler)
self.stop_list.append(scheduler)
chatbot.run_init()
return chatbot
def run(self):
for server_name in settings.sections():
server = Server(server_name,
settings.setting(server_name, "address"),
settings.setting(server_name, "username"),
settings.setting(server_name, "password"))
server.game_password = \
settings.setting(server_name, "game_password")
server.url_extras = \
settings.setting(server_name, "url_extras")
dosh_threshold = int(
settings.setting(server_name, "dosh_threshold"))
if dosh_threshold > 0:
server.dosh_threshold = dosh_threshold
has_motd_scoreboard = str_to_bool(
settings.setting(server_name, "motd_scoreboard"))
if has_motd_scoreboard:
scoreboard_type = settings.setting(server_name,
"scoreboard_type")
MotdUpdater(server, scoreboard_type).start()
self.servers.append(server)
Chatbot(
server,
str_to_bool(settings.setting(server_name, "enable_greeter")),
settings.setting(server_name, "username"))
info("Initialisation complete!\n")
while True:
command = input()
for server in self.servers:
server.web_admin.chat.submit_message(command)
from flask import Flask, render_template
from flask import request
from chatbot.chatbot import Chatbot
bot = Chatbot()
app = Flask(__name__)
@app.route("/")
def home():
return render_template("index.html")
@app.route('/ask', methods=['GET', 'POST'])
def ask():
question = request.form["question"]
answer = bot.answer(question)
return question + "</>" + answer
if __name__ == "__main__":
app.run()
def init_chatbot():
bot = Chatbot()
bot.start()
return bot
