def main():
print "==" * 50
args = parse_args()
timeout = args.timeout
get_text_from_image = partial(bai_get_text,
app_id=app_id,
app_key=app_key,
app_secret=app_secret,
timeout=timeout)
start = time.time()
text_binary = analyze_current_screen_text(directory=data_directory)
keywords = get_text_from_image(image_data=text_binary, )
if not keywords:
print("text not recognize")
return
question, answers, is_negate = parse_question_and_answer(keywords)
print("-" * 50)
print question
print("-" * 50)
print("\n".join(answers))
print "-" * 50, "\n"
result_list = search(question)
best_result = analyze(result_list, question, answers, is_negate)
end = time.time()
if best_result is None:
print('\n没有答案')
open_webbrowser(question)
else:
result = "\n" + "=" * 25 + "\n" + "最佳答案是： " + best_result + "\n" + "=" * 25
msg.showinfo("答案", result)
def main():
args = parse_args()
timeout = args.timeout
start = time.time()
text_binary = analyze_current_screen_text(
directory=data_directory, compress_level=image_compress_level[0])
keyword = get_text_from_image(image_data=text_binary, )
if not keyword:
print("text not recognize")
return
keyword = keyword_normalize(keyword)
print("guess keyword: ", keyword)
answers = zhidao_search(keyword=keyword,
default_answer_select=default_answer_number,
timeout=timeout)
answers = filter(None, answers)
for text in answers:
print('=' * 70)
text = text.replace("\u3000", "")
if len(text) > 120 and text_summary:
sentences = get_summary(text, summary_sentence_count)
sentences = filter(None, sentences)
if not sentences:
print(text)
else:
print("\n".join(sentences))
else:
print("\n".join(textwrap.wrap(text, width=45)))
end = time.time()
print("use {0} 秒".format(end - start))
save_screen(directory=data_directory)
def __inner_job():
start = time.time()
image_binary = analyze_current_screen_text(
directory=data_directory,
compress_level=image_compress_level[0],
crop_area=crop_areas[game_type]
)
if not image_binary:
print("do not detect question and answers")
return
keywords = get_text_from_image(
image_data=image_binary,
timeout=timeout
)
if not keywords:
print("text not recognize")
return
true_flag, real_question, question, answers = parse_question_and_answer(keywords)
### parse for answer
answers = map(lambda a: a.rsplit(":")[-1], answers)
answers = list(map(lambda a: a.rsplit(".")[-1], answers))
print("~" * 60)
print("{0}\n{1}".format(real_question, "\n".join(answers)))
print("~" * 60)
if enable_chrome:
writer.send(question)
noticer.set()
summary = baidu_count(question, answers, timeout=timeout)
summary_li = sorted(summary.items(), key=operator.itemgetter(1), reverse=True)
if true_flag:
recommend = "{0}\n{1}".format(
"肯定回答(**)： {0}".format(summary_li[0][0]),
"否定回答( )： {0}".format(summary_li[-1][0]))
else:
recommend = "{0}\n{1}".format(
"肯定回答( )： {0}".format(summary_li[0][0]),
"否定回答(**)： {0}".format(summary_li[-1][0]))
print("*" * 60)
print(recommend)
print("*" * 60)
ans = kwquery(real_question)
print("-" * 60)
print(wrap(" ".join(ans), 60))
print("-" * 60)
end = time.time()
print("use {0} 秒".format(end - start))
save_screen(directory=data_directory)
save_question_answers_to_file(real_question, answers, directory=data_directory)
def main(testfile):
four_answers = False
args = parse_args()
timeout = args.timeout
start = time.time()
if testfile > -1:
text_binary = analyze_current_screen_text(directory=data_directory,
file_name=testfile + 1,
test=True)
else:
text_binary = analyze_current_screen_text(directory=data_directory)
end = time.time()
print("处理图片时间 {0} 秒".format(end - start))
keyword, q1, q2, q3, q4 = analysis(text_binary, four_answers=four_answers)
# keyword = get_text_from_image(
# image_data=text_binary,
# appcode=hanwan_appcode
# )
if not keyword:
print("text not recognize")
return
end = time.time()
print("图片生成文本时间 {0} 秒".format(end - start))
keyword = keyword.split(r".")[-1]
keywords = keyword.split(" ")
keyword = "".join([e.strip("\r\n") for e in keywords if e])
print("guess keyword: ", keyword)
# answers = zhidao_search(
# keyword=keyword,
# default_answer_select=default_answer_number,
# timeout=timeout
# )
answers = parse_search(keyword=keyword,
default_answer_select=default_answer_number,
timeout=timeout)
end = time.time()
print("获取答案时间 {0} 秒".format(end - start))
answers = filter(None, answers)
choose_answer = match_words(answers, (keyword, q1, q2, q3, q4),
four_answers=four_answers)
end = time.time()
print("use {0} 秒".format(end - start))
def __inner_job(answer_num):
start = time.time()
text_binary = analyze_current_screen_text(
answer_num,
directory=data_directory,
compress_level=image_compress_level[0])
keywords = get_text_from_image(image_data=text_binary, )
if not keywords:
print("text not recognize")
return
question, answers = parse_question_and_answer(keywords, answer_num)
answers = answers[:3]
webbrowser.open('https://baidu.com/s?wd=' + question)
print('-' * 72)
print(question)
print('-' * 72)
print("\n".join(answers))
search_question = analyze_keyword_from_question(question)
weight_li, final, index = calculate_relation(search_question, answers)
min_member = min(weight_li)
max_member = max(weight_li)
normalize = partial(number_normalize,
max_member=max_member,
min_member=min_member,
c=100)
summary = {a: b for a, b in zip(answers, weight_li)}
summary_li = sorted(summary.items(),
key=operator.itemgetter(1),
reverse=True)
data = [("选项", "同比")]
for a, w in summary_li:
data.append((a, "{:.3f}".format(
normalize(w) if max_member > min_member else w)))
table = SingleTable(data)
print(table.table)
print("*" * 72)
print("肯定回答： ", summary_li[0][0])
print("否定回答： ", summary_li[-1][0])
print("*" * 72)
end = time.time()
print("use {0} 秒".format(end - start))
save_screen(directory=data_directory)
save_question_answers_to_file(question,
answers,
directory=data_directory)
def __inner_job(index=choice):
start = time.time()
text_binary = analyze_current_screen_text(
directory=data_directory,
compress_level=image_compress_level[1],
index=choice
)
keywords = get_text_from_image(
image_data=text_binary,
)
##print('中国',keywords)
if not keywords:
print("failed")
return
##true_flag,问题是否为正向问题，选择错误项的问题为反向问题
true_flag, question, answers = parse_question_and_answer(keywords)
print('\n',question)
# notice browser
if enable_chrome:
with question_obj.get_lock():
question_obj.value = question
keyboard.press("space")
search_question = pre_process_question(question)
summary = baidu_count(search_question, answers, timeout=timeout)
summary_li = sorted(summary.items(), key=operator.itemgetter(1), reverse=True)
data = [("选项", "相关度")]
for a, w in summary_li:
data.append((a, w))
table = AsciiTable(data)
print(table.table)
print("*" * 36)
if true_flag:
print("肯定回答(**)： ", summary_li[0][0])
print("否定回答( )： ", summary_li[-1][0])
else:
print("肯定回答( )： ", summary_li[0][0])
print("否定回答(**)： ", summary_li[-1][0])
print("*" * 36)
end = time.time()
print("use {0} 秒".format(end - start))
save_screen(
directory=data_directory
)
def main():
args = parse_args()
timeout = args.timeout
start = time.time()
text_binary = analyze_current_screen_text(
directory=data_directory, compress_level=image_compress_level[0])
keyword = get_text_from_image(image_data=text_binary, )
if not keyword:
print("text not recognize")
return
keyword = keyword_normalize(keyword)
print("guess keyword: ", keyword)
# 直接打开百度搜索结果（针对原项目增加百度搜索结果）
# 构建百度搜索URL
URL = "https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=0&rsv_idx=1&tn=baidu&wd=" + keyword + "&rsv_pq=c5275ac400006206&rsv_t=934bk5QLv0mlKbgJEPtAVMjYqGoybaZuUGqUdJ2Krw%2B2qr2LsF5TvhzzmcU&rqlang=cn&rsv_enter=1&rsv_sug3=4&rsv_sug1=2&rsv_sug7=100&rsv_sug2=0&inputT=2869&rsv_sug4=3213"
# 设定特定浏览器打开链接
# 替换为自己的chrome浏览器安装位置（同样支持支持火狐浏览器）
# chrome_path = "C:\Program Files (x86)\Google\Chrome\Application\chrome.exe"
# webbrowser.register('chrome', None, webbrowser.BackgroundBrowser(chrome_path), 1)
# webbrowser.get('chrome').open_new_tab(URL)
# 使用默认浏览器打开链接
webbrowser.open(URL)
# 原作者使用百度知道搜索结果及其后续处理
answers = zhidao_search(keyword=keyword,
default_answer_select=default_answer_number,
timeout=timeout)
answers = filter(None, answers)
for text in answers:
print('=' * 70)
text = text.replace("\u3000", "")
if len(text) > 120 and text_summary:
sentences = get_summary(text, summary_sentence_count)
sentences = filter(None, sentences)
if not sentences:
print(text)
else:
print("\n".join(sentences))
else:
print("\n".join(textwrap.wrap(text, width=45)))
end = time.time()
print("use {0} 秒".format(end - start))
def __inner_job():
start = time.time()
text_binary = analyze_current_screen_text(
directory=data_directory,
compress_level=image_compress_level[0]
)
keywords = get_text_from_image(
image_data=text_binary,
)
if not keywords:
print("text not recognize")
return
true_flag, question, answers = parse_question_and_answer(keywords)
print('-' * 72)
print(question)
print('-' * 72)
print("\n".join(answers))
# notice browser
if enable_chrome:
with question_obj.get_lock():
question_obj.value = question
keyboard.press("space")
search_question = pre_process_question(question)
summary = baidu_count(search_question, answers, timeout=timeout)
summary_li = sorted(summary.items(), key=operator.itemgetter(1), reverse=True)
data = [("选项", "同比")]
for a, w in summary_li:
data.append((a, w))
table = AsciiTable(data)
print(table.table)
print("*" * 72)
if true_flag:
print("肯定回答(**)： ", summary_li[0][0])
print("否定回答( )： ", summary_li[-1][0])
else:
print("肯定回答( )： ", summary_li[0][0])
print("否定回答(**)： ", summary_li[-1][0])
print("*" * 72)
end = time.time()
print("use {0} 秒".format(end - start))
save_screen(
directory=data_directory
)
def __inner_job():
start = time.time()
image_binary = analyze_current_screen_text(
directory=data_directory,
compress_level=image_compress_level[0],
crop_area=crop_areas[game_type]
)
if not image_binary:
print("do not detect question and answers")
return
keywords = get_text_from_image(
image_data=image_binary,
timeout=timeout
)
if not keywords:
print("text not recognize")
return
true_flag, real_question, question, answers = parse_question_and_answer(keywords)
### parse for answer
### 3个答案选项
answers = map(lambda a: a.rsplit(":")[-1], answers)
answers = list(map(lambda a: a.rsplit(".")[-1], answers))
std_pipe.write(stdout_template.QUESTION_TPL.format(real_question, "\n".join(answers)))
# notice baidu and craw
baidu_queue.put((
question, answers, true_flag
))
knowledge_queue.put(question)
if enable_chrome:
writer.send(question)
noticer.set()
end = time.time()
std_pipe.write(stdout_template.TIME_CONSUME_TPL.format(end - start))
save_screen(directory=data_directory)
save_question_answers_to_file(real_question, answers, directory=data_directory)
def main():
args = parse_args()
timeout = args.timeout
start = time.time()
text_binary = analyze_current_screen_text(
directory=data_directory,
compress_level=image_compress_level[0]
)
keyword = get_text_from_image(
image_data=text_binary,
)
if not keyword:
print("text not recognize")
return
keyword = keyword_normalize(keyword)
print("guess keyword: ", keyword)
answers = zhidao_search(
keyword=keyword,
default_answer_select=default_answer_number,
timeout=timeout
)
answers = filter(None, answers)
for text in answers:
print('=' * 70)
text = text.replace("\u3000", "")
if len(text) > 120 and text_summary:
sentences = get_summary(text, summary_sentence_count)
sentences = filter(None, sentences)
if not sentences:
print(text)
else:
print("\n".join(sentences))
else:
print("\n".join(textwrap.wrap(text, width=45)))
end = time.time()
print("use {0} 秒".format(end - start))
def __inner_job():
start = time.time()
image_binary = analyze_current_screen_text(
directory=data_directory,
compress_level=image_compress_level[0],
crop_area=crop_areas[game_type]
)
if not image_binary:
print("do not detect question and answers")
return
keywords = get_text_from_image(
image_data=image_binary,
timeout=timeout
)
if not keywords:
print("text not recognize")
return
true_flag, real_question, question, answers = parse_question_and_answer(keywords)
### parse for answer
answers = map(lambda a: a.rsplit(":")[-1], answers)
answers = list(map(lambda a: a.rsplit(".")[-1], answers))
std_pipe.write(stdout_template.QUESTION_TPL.format(real_question, "\n".join(answers)))
# notice baidu and craw
baidu_queue.put((
question, answers, true_flag
))
knowledge_queue.put(question)
if enable_chrome:
writer.send(question)
noticer.set()
end = time.time()
std_pipe.write(stdout_template.TIME_CONSUME_TPL.format(end - start))
save_screen(directory=data_directory)
save_question_answers_to_file(real_question, answers, directory=data_directory)
def __inner_job():
start = time.time()
text_binary = analyze_current_screen_text(
directory=data_directory,
compress_level=image_compress_level[0],
crop_area=crop_areas[game_type],
use_monitor=use_monitor)
keywords = get_text_from_image(image_data=text_binary, timeout=timeout)
if not keywords:
print("text not recognize")
return
true_flag, real_question, question, answers = parse_question_and_answer(
keywords)
if game_type == "UC答题":
answers = map(lambda a: a.rsplit(":")[-1], answers)
### refresh question
stdout_queue.put({
"type":
0,
"data":
"{0}\n{1}".format(question, "\n".join(answers))
})
# notice baidu and craw
baidu_queue.put((question, answers, true_flag))
knowledge_queue.put(question)
if enable_chrome:
writer.send(question)
noticer.set()
end = time.time()
stdout_queue.put({"type": 3, "data": "use {0} 秒".format(end - start)})
save_screen(directory=data_directory)
time.time(1)
def __inner_job():
start = time.time()
text_binary = analyze_current_screen_text(
directory=data_directory,
compress_level=image_compress_level[0],
crop_area=crop_areas[game_type],
use_monitor=use_monitor)
keywords = get_text_from_image(image_data=text_binary, timeout=timeout)
if not keywords:
print("text not recognize")
return
true_flag, real_question, question, answers = parse_question_and_answer(
keywords)
if game_type == "UC答题":
answers = map(lambda a: a.rsplit(":")[-1], answers)
print("~" * 60)
print("{0}\n{1}".format(real_question, "\n".join(answers)))
print("~" * 60)
# ### refresh question
# stdout_queue.put({
# "type": 0,
# "data": "{0}\n{1}".format(question, "\n".join(answers))
# })
#
# # notice baidu and craw
# baidu_queue.put((
# question, answers, true_flag
# ))
# knowledge_queue.put(question)
if enable_chrome:
writer.send(question)
noticer.set()
summary = baidu_count(question, answers, timeout=timeout)
summary_li = sorted(summary.items(),
key=operator.itemgetter(1),
reverse=True)
if true_flag:
recommend = "{0}\n{1}".format(
"肯定回答(**)： {0}".format(summary_li[0][0]),
"否定回答( )： {0}".format(summary_li[-1][0]))
else:
recommend = "{0}\n{1}".format(
"肯定回答( )： {0}".format(summary_li[0][0]),
"否定回答(**)： {0}".format(summary_li[-1][0]))
print("*" * 60)
print("\n".join(
map(lambda item: "{0}: {1}".format(item[0], item[1]), summary_li)))
print(recommend)
print("*" * 60)
ans = kwquery(real_question)
print("-" * 60)
print(wrap(" ".join(ans), 60))
print("-" * 60)
end = time.time()
# stdout_queue.put({
# "type": 3,
# "data": "use {0} 秒".format(end - start)
# })
print("use {0} 秒".format(end - start))
save_screen(directory=data_directory)
time.sleep(1)
def __inner_job():
start = time.time()
text_binary = analyze_current_screen_text(
directory=data_directory,
compress_level=image_compress_level[0],
crop_area=crop_areas[game_type],
use_monitor=use_monitor)
keywords = get_text_from_image(image_data=text_binary, )
if not keywords:
print("text not recognize")
return
true_flag, real_question, question, answers = parse_question_and_answer(
keywords)
## notice crawler to work
# qwriter.send(real_question.strip("?"))
# crawler_noticer.set()
print('-' * 72)
print(real_question)
print('-' * 72)
print("\n".join(answers))
# notice browser
if enable_chrome:
writer.send(question)
noticer.set()
search_question = pre_process_question(question)
summary = baidu_count(search_question, answers, timeout=timeout)
summary_li = sorted(summary.items(),
key=operator.itemgetter(1),
reverse=True)
data = [("选项", "同比")]
for a, w in summary_li:
data.append((a, w))
table = AsciiTable(data)
print(table.table)
print("*" * 72)
if true_flag:
print("肯定回答(**)： ", summary_li[0][0])
print("否定回答( )： ", summary_li[-1][0])
else:
print("肯定回答( )： ", summary_li[0][0])
print("否定回答(**)： ", summary_li[-1][0])
print("*" * 72)
# try crawler
# retry = 4
# while retry:
# if result_noticer.is_set():
# print("~" * 60)
# print(stdreader.recv())
# print("~" * 60)
# break
# retry -= 1
# time.sleep(1)
# result_noticer.clear()
print("~" * 60)
print(kwquery(real_question.strip("?")))
print("~" * 60)
end = time.time()
print("use {0} 秒".format(end - start))
save_screen(directory=data_directory)
def __inner_job():
start = time.time()
text_binary = analyze_current_screen_text(
directory=data_directory, compress_level=image_compress_level[0])
keywords = get_text_from_image(image_data=text_binary, )
if not keywords:
print("text not recognize")
return
true_flag, question, answers = parse_question_and_answer(keywords)
#questions=question.decode('unicode-escape')
#new_ans=[]
#for ans in answers:
# new_ans.append(ans.decode('unicode-escape'))
print('-' * 72)
print(question)
print('-' * 72)
print("\n".join(answers))
# notice browser
if enable_chrome:
with question_obj.get_lock():
question_obj.value = question
keyboard.press("space")
search_question = pre_process_question(question)
summary = baidu_count(search_question, answers, timeout=timeout)
summary_li = sorted(summary.items(),
key=operator.itemgetter(1),
reverse=True)
data = [("选项", "同比")]
for a, w in summary_li:
data.append((a, w))
table = AsciiTable(data)
print(table.table)
print("*" * 72)
if true_flag:
print("肯定回答(**)： ", summary_li[0][0])
print("否定回答( )： ", summary_li[-1][0])
else:
print("肯定回答( )： ", summary_li[0][0])
print("否定回答(**)： ", summary_li[-1][0])
print("*" * 72)
##############################################################
input_message = question
if len(input_message) > 60:
print(mybot.respond("句子长度过长"))
elif input_message.strip() == '':
print(mybot.respond("无"))
#print(input_message)
message = T.wordSegment(input_message)
# 去标点
#print('word Seg:' + message)
#print('词性：')
words = T.postag(input_message)
if message == 'q':
exit()
else:
response = mybot.respond(message)
#print("=======")
#print(response)
#print("=======")
if response == "":
ans = mybot.respond('找不到答案')
print('Eric：' + ans)
# 百科搜索
elif response[0] == '#':
# 匹配百科
if response.__contains__("searchbaike"):
#print("searchbaike")
#print(response)
res = response.split(':')
# 实体
entity = str(res[1]).replace(" ", "")
# 属性
attr = str(res[2]).replace(" ", "")
#print(entity + '<---->' + attr)
ans = baike.query(entity, attr)
# 如果命中答案
if type(ans) == list:
print('Eric：' + QAT.ptranswer(ans, False))
elif ans.decode('utf-8').__contains__(u'::找不到'):
# 百度摘要+Bing摘要
print("通用搜索")
ans = search_summary.kwquery(input_message)
# 匹配不到模版，通用查询
elif response.__contains__("NoMatchingTemplate"):
#print("NoMatchingTemplate")
ans = search_summary.kwquery(input_message, answers)
if len(ans) == 0:
print('Eric：' + '找不到答案')
elif len(ans) > 1:
print("不确定候选答案")
print('Eric: ')
for a in ans:
print(a)
else:
print('Eric：' + ans[0])
# 匹配模版
else:
print('Eric：' + response)
end = time.time()
print("use {0} 秒".format(end - start))
save_screen(directory=data_directory)
def __inner_job():
global isNegativeQuestion, origQuestion, isExceptionGame
start = time.time()
cur_path = os.path.abspath(os.curdir)
path = cur_path + "\\screenshots"
if not os.path.exists(path):
os.makedirs(path)
if game_platform != 3:
if game_platform == 2:
text_binary = analyze_current_screen_text(
directory=data_directory,
compress_level=image_compress_level[0],
crop_area=crop_areas[game_type])
else:
text_binary = analyze_current_screen_text_ios(
directory=data_directory,
compress_level=image_compress_level[0],
crop_area=crop_areas[game_type])
keywords = get_text_from_image(image_data=text_binary, )
if not keywords:
print("本题不能识别，请尽快自行作答！")
return
true_flag, real_question, question, answers = parse_question_and_answer(
keywords)
else:
true_flag, real_question, question, answers = parse_question_and_answer(
test_key)
orig_answer = answers
# 分词预处理
allanswers = ''
optioncount = 0
isNewAlgUsable = False
isAnswerAllNum = False
for i in answers:
allanswers = allanswers + i
optioncount += 1
if i.isdigit():
isAnswerAllNum = True
if isAnswerAllNum == False:
repeatanswers = get_repeat_num_seq(allanswers)
else:
repeatanswers = [['', 0]]
maxlen = 0
delword = '' # 预分词目标：找到选项中的重复部分，提升选项之间的差异性
if optioncount >= 3:
isNewAlgUsable = True
if isNewAlgUsable:
if isAnswerAllNum == False:
for (d, x) in repeatanswers:
if x >= 3 and len(d) > maxlen:
maxlen = len(d)
delword = d
else:
delword = ''
print("")
print("*" * 40)
print('题目： ' + origQuestion)
print("*" * 40)
# notice browser
if enable_chrome:
writer.send(question)
noticer.set()
search_question = pre_process_question(question)
thd1 = SearchThread(search_question, answers, timeout, delword,
'baidu')
thd2 = SearchThread(search_question, answers, timeout, delword, 'bing')
thd3 = SearchThread(search_question, answers, timeout, delword,
'zhidao')
thd7 = SearchThread(search_question, answers, timeout, delword, 'so')
if isNewAlgUsable:
# V4.7 修正OCR识别不全导致无法继续检索的问题。 Thanks To Github/Misakio （数组越界）
search_question_1 = search_question + " " + answers[0].replace(
delword, "")
search_question_2 = search_question + " " + answers[1].replace(
delword, "")
search_question_3 = search_question + " " + answers[2].replace(
delword, "")
thd4 = SearchThread(search_question_1,
answers,
timeout,
delword,
'baidu',
numofquery=10)
thd5 = SearchThread(search_question_2,
answers,
timeout,
delword,
'baidu',
numofquery=10)
thd6 = SearchThread(search_question_3,
answers,
timeout,
delword,
'baidu',
numofquery=10)
# QMI算法7线程
thd_QA1 = SearchThread(search_question_1,
answers,
timeout,
delword,
'baiduqmi',
numofquery=5)
thd_QA2 = SearchThread(search_question_2,
answers,
timeout,
delword,
'baiduqmi',
numofquery=5)
thd_QA3 = SearchThread(search_question_3,
answers,
timeout,
delword,
'baiduqmi',
numofquery=5)
thd_A1 = SearchThread(answers[0],
answers,
timeout,
delword,
'baiduqmi',
numofquery=5)
thd_A2 = SearchThread(answers[1],
answers,
timeout,
delword,
'baiduqmi',
numofquery=5)
thd_A3 = SearchThread(answers[2],
answers,
timeout,
delword,
'baiduqmi',
numofquery=5)
thd_Q = SearchThread(search_question,
answers,
timeout,
delword,
'baiduqmi',
numofquery=5)
# 创立并发线程
if __name__ == '__main__':
thd1.setDaemon(True)
thd1.start()
thd2.setDaemon(True)
thd2.start()
thd3.setDaemon(True)
thd3.start()
thd7.setDaemon(True)
thd7.start()
if isNewAlgUsable:
thd4.setDaemon(True)
thd4.start()
thd5.setDaemon(True)
thd5.start()
thd6.setDaemon(True)
thd6.start()
thd_QA1.setDaemon(True)
thd_QA1.start()
thd_QA2.setDaemon(True)
thd_QA2.start()
thd_QA3.setDaemon(True)
thd_QA3.start()
thd_A1.setDaemon(True)
thd_A1.start()
thd_A2.setDaemon(True)
thd_A2.start()
thd_A3.setDaemon(True)
thd_A3.start()
thd_Q.setDaemon(True)
thd_Q.start()
# 顺序开启3线程
thd1.join()
thd2.join()
thd3.join()
thd7.join()
if isNewAlgUsable:
thd4.join()
thd5.join()
thd6.join()
thd_QA1.join()
thd_QA2.join()
thd_QA3.join()
thd_A1.join()
thd_A2.join()
thd_A3.join()
thd_Q.join()
# 等待线程执行结束
summary = thd1.get_result()
summary2 = thd2.get_result()
summary3 = thd3.get_result()
summary7 = thd7.get_result()
if isNewAlgUsable:
summary4 = thd4.get_result()
summary5 = thd5.get_result()
summary6 = thd6.get_result()
num_QA1 = thd_QA1.get_result()
num_QA2 = thd_QA2.get_result()
num_QA3 = thd_QA3.get_result()
num_A1 = thd_A1.get_result()
num_A2 = thd_A2.get_result()
num_A3 = thd_A3.get_result()
num_Q = thd_Q.get_result()
# 获取线程执行结果
# 下面开始合并结果并添加可靠性标志
creditFlag = True
credit = 0
summary_t = summary
for i in range(0, len(summary)):
summary_t[answers[i]] += summary2[answers[i]]
summary_t[answers[i]] += summary7[answers[i]]
summary_t[answers[i]] += summary3[answers[i]]
credit += summary_t[answers[i]]
va = summary_t.values()
if credit < 2 or var(summary_t.values()) < 0.71:
creditFlag = False
if isNegativeQuestion == False:
summary_li = sorted(summary_t.items(),
key=operator.itemgetter(1),
reverse=True)
else:
summary_li = sorted(summary_t.items(),
key=operator.itemgetter(1),
reverse=False)
summary_newalg = dict()
if isNewAlgUsable:
# 先算一下QMI指数
A1_qmi = (num_QA1) / (num_Q * num_A1)
A2_qmi = (num_QA2) / (num_Q * num_A2)
A3_qmi = (num_QA3) / (num_Q * num_A3)
qmi_max = max(A1_qmi, A2_qmi, A3_qmi)
# 配置模型控制参数
if isNegativeQuestion:
weight1 = 10
adding1 = 1
weight2 = 1
adding2 = 10
else:
weight1 = 10
adding1 = 1
weight2 = 1
adding2 = 10
a = (summary_t[orig_answer[0]] * weight1 + adding1) * (
((summary5[orig_answer[0]] + summary6[orig_answer[0]])) *
weight2 + adding2)
b = (summary_t[orig_answer[1]] * weight1 + adding1) * (
((summary4[orig_answer[1]] + summary6[orig_answer[1]])) *
weight2 + adding2)
c = (summary_t[orig_answer[2]] * weight1 + adding1) * (
((summary4[orig_answer[2]] + summary5[orig_answer[2]])) *
weight2 + adding2)
similar_max = max(a, b, c)
# 以下判断没有严格的理论基础，暂时不开启
if isNegativeQuestion and creditFlag == False and False:
a = similar_max - a + 1
b = similar_max - b + 1
c = similar_max - c + 1
a = float("%.6f" % ((a / (similar_max)) * (A1_qmi / (qmi_max))))
b = float("%.6f" % ((b / (similar_max)) * (A2_qmi / (qmi_max))))
c = float("%.6f" % ((c / (similar_max)) * (A3_qmi / (qmi_max))))
summary_newalg.update({orig_answer[0]: (a)})
summary_newalg.update({orig_answer[1]: (b)})
summary_newalg.update({orig_answer[2]: (c)})
data = [("选项", "权重", "相似度")]
topscore = 0
for ans, w in summary_li:
if w > topscore:
topscore = w
for ans, w in summary_li:
if isNegativeQuestion == False:
if isNewAlgUsable: # 修正V4的BUG：可能导致不能继续识别的问题
data.append((ans, w, summary_newalg[ans]))
else:
data.append((ans, w, '0'))
else:
if isNewAlgUsable:
data.append((ans, topscore - w + 1, summary_newalg[ans]))
else:
data.append((ans, topscore - w + 1, '0'))
table = AsciiTable(data)
print(table.table)
print("")
end = time.time()
print("分析结果 耗时 {0} 秒 听语音更靠谱".format("%.1f" % (end - start)))
print("*" * 40)
print("")
if creditFlag == False:
print(" ！【 本题预测结果不是很可靠，请慎重 】 ！")
if isNegativeQuestion == True:
print(" ！【 本题是否定提法，已帮您优化结果！ 】 ！")
if isNewAlgUsable == False:
print(" √ 混合算法建议 ： ", summary_li[0][0], ' (第',
orig_answer.index(summary_li[0][0]) + 1, '项)')
# 测试：新匹配算法
if isNegativeQuestion == True:
ngflg = '1'
else:
ngflg = '0'
if isNewAlgUsable:
if isNegativeQuestion == False:
summary_li2 = sorted(summary_newalg.items(),
key=operator.itemgetter(1),
reverse=True) #True
else:
summary_li2 = sorted(summary_newalg.items(),
key=operator.itemgetter(1),
reverse=False) #False
print(" √ 关联算法建议 ： ", summary_li2[0][0], ' (第',
orig_answer.index(summary_li2[0][0]) + 1, '项)')
# 神经网络计算，采用预训练参数
feature = np.array([
int(summary_t[orig_answer[0]]),
int(summary_t[orig_answer[1]]),
int(summary_t[orig_answer[2]]),
int(summary4[orig_answer[0]]),
int(summary4[orig_answer[1]]),
int(summary4[orig_answer[2]]),
int(summary5[orig_answer[0]]),
int(summary5[orig_answer[1]]),
int(summary5[orig_answer[2]]),
int(summary6[orig_answer[0]]),
int(summary6[orig_answer[1]]),
int(summary6[orig_answer[2]]),
float('%.5f' % (A1_qmi / qmi_max)),
float('%.5f' % (A2_qmi / qmi_max)),
float('%.5f' % (A3_qmi / qmi_max))
])
feature = np.matrix(feature)
nn_re = predict(feature, get_theta1(isNegativeQuestion),
get_theta2(isNegativeQuestion))
nn_re = nn_re[0]
#print(nn_re)
nn_re = nn_re.index(max(nn_re))
print(' √ 神经网络输出 ： ', orig_answer[nn_re], ' (第',
str(nn_re + 1), '项)')
if orig_answer.index(
summary_li2[0][0]) == nn_re and creditFlag == True:
print(" √ 【 结果可信度高 ，选择 第",
orig_answer.index(summary_li[0][0]) + 1, "项 ！】")
speak("第{}项{}".format(
orig_answer.index(summary_li[0][0]) + 1, summary_li[0][0]))
print(" × 排除选项 ： ", summary_li2[-1][0])
elif creditFlag == False:
speak("谨慎第{}项谨慎".format(
orig_answer.index(summary_li2[0][0]) + 1))
print(" × 排除选项 ： ", summary_li2[-1][0])
else:
speak("谨慎第{}项谨慎".format(nn_re + 1))
print(" × 排除选项 ： ", summary_li[-1][0])
else:
speak("谨慎第{}项谨慎".format(orig_answer.index(summary_li[0][0]) + 1))
print("选项识别有些问题，新算法此题未开启")
print(" × 排除选项 ： ", summary_li[-1][0])
if game_platform == 3:
print('')
print(orig_answer)
real_answer = input("请输入本题正确答案：")
with open('testset_record_feature.txt', 'a+') as f:
featurestr = str(summary_t[orig_answer[0]]) + '|' + str(
summary_t[orig_answer[1]]) + '|' + str(
summary_t[orig_answer[2]])
featurestr += '|' + str(summary4[orig_answer[0]]) + '|' + str(
summary4[orig_answer[1]]) + '|' + str(
summary4[orig_answer[2]])
featurestr += '|' + str(summary5[orig_answer[0]]) + '|' + str(
summary5[orig_answer[1]]) + '|' + str(
summary5[orig_answer[2]])
featurestr += '|' + str(summary6[orig_answer[0]]) + '|' + str(
summary6[orig_answer[1]]) + '|' + str(
summary6[orig_answer[2]])
featurestr += '|' + ('%.5f' % (A1_qmi / qmi_max)) + '|' + (
'%.5f' % (A2_qmi / qmi_max)) + '|' + (
'%.5f' % (A3_qmi / qmi_max)
) + '|' + ngflg + '|' + real_answer + '\n'
f.write(featurestr)
if game_platform != 3:
# 输出知识树
thdtree = SearchThread(search_question, answers, timeout, delword,
'zhidaotree')
thdtree.setDaemon(True)
thdtree.start()
thdtree.join()
summary_tree = thdtree.get_result()
print("")
print("")
print("辅助知识树")
print("*" * 40)
for ans in summary_tree:
print(ans)
save_screen(directory=data_directory)
save_record(origQuestion, orig_answer)
