def run(self, topic_path, size=None, summarizer="SUME", summary_idx=None, parser=None, oracle="accept", feedback_log=None, propagation=False, max_iteration_count=10, preload_embeddings=None, feedbackstore=None, override_results_files=False, num_clusters=8): log = logging.getLogger("SingleTopicRunner") sf = None # just for the sake of being able to run without simulated feedback... self.tlog.debug("SingleTopicRunner started") # relativize the topic path! if type(topic_path) is Topic: topic = topic_path else: if topic_path.startswith("/"): relative_path = re.search('^(/)(.*)$', topic_path).group(2) else: relative_path = topic_path topic = Topic( path.join(self.iobasedir, path.normpath(relative_path))) language = topic.get_language() docs = topic.get_docs() summaries = topic.get_models() flightrecorder = get_flightrecorder_from_file(feedback_log) preceding_size = len( flightrecorder.records ) # the number of iterations that happened due to the provided feedback_log embeddings = None """ if preload_embeddings: embeddings_path = path.normpath(path.join(self.iobasedir, "embeddings")) embeddings = load_w2v_embeddings(embeddings_path, language, 'active_learning') else: embeddings = preload_embeddings """ if summary_idx is not None: summaries = [summaries[summary_idx]] if size is None: use_size = topic.get_summary_size() else: use_size = size clusters_path = path.join(self.iobasedir, 'clustering', '{}'.format(num_clusters)) #print(clusters_path) #clusters = get_clusters(clusters_path, topic.docs_dir) if summarizer == "SUME": sw = SumeWrap(language) summary = sw(docs, use_size) outputfilecontents = { "summary": summary, "type": summarizer, "info_data": [] } json_content = json.dumps(outputfilecontents) if self.out is not None: log.info("writing output to %s" % (self.out)) write_to_file(json_content, self.out) write_to_file( json_content, path.normpath( path.expanduser( path.join(self.iobasedir, "tmp", "tmp.json")))) elif summarizer == "UPPER_BOUND": ub_summary = load_ub_summary(language, docs, summaries, use_size, base_dir=self.iobasedir) summary = '\n'.join(ub_summary) outputfilecontents = { "summary": summary, "type": summarizer, "info_data": [] } json_content = json.dumps(outputfilecontents) if self.out is not None: log.info("writing output to %s" % (self.out)) write_to_file(json_content, self.out) write_to_file( json_content, path.normpath( path.expanduser( path.join(self.iobasedir, "tmp", "tmp.json")))) elif summarizer == "PROPAGATION": #UB considering all the summaries ub_summary = load_ub_summary(language, docs, summaries, use_size, base_dir=self.iobasedir) summary = '\n'.join(ub_summary) ub_scores = self.rouge(summary, summaries, use_size) log.debug( "UB scores: R1:%s R2:%s SU4:%s" % (str(ub_scores[0]), str(ub_scores[1]), str(ub_scores[2]))) ref_summ = random.choice(summaries) parse_info = [] #parse_info = topic.get_parse_info(summaries.index(ref_summ)) # initialize the Algorithm. run_config = dict() run_config['rank_subset'] = True run_config['relative_k'] = True run_config['dynamic_k'] = False for flag in ['adaptive_sampling', 'strategy']: run_config[flag] = False r = 0 clusters = None log.info("recording k_size in summarize %f", self.k) #TODO: Added summaries instead of one single summary sf = SimulatedFeedback( language, self.rouge, embeddings=None, #TODO: embeddings docs=docs, models=summaries, summary_length=use_size, oracle_type=oracle, ub_score=ub_scores, ub_summary=ub_summary, parser_type=parser, flightrecorder=flightrecorder, feedbackstore=feedbackstore, parse_info=parse_info, run_config=run_config, k=self.k, adaptive_window_size=r, clusters=clusters) if sf.embeddings is None or sf.embeddings == {}: embe_var = "none", else: if sf.embeddings.embedding_variant is None: embe_var = "none" else: embe_var = sf.embeddings.embedding_variant if feedbackstore is None: cfg = {"type": "Unconfigured default"} else: cfg = feedbackstore.get_config() rs = [] for p, t in [ref_summ]: rs.append({"name": os.path.split(p)[1], "text": t}) run_id_string = "%s-%s-%s-%s-%s-%s-%s-%s" % ( oracle, summarizer, parser, embe_var, topic.get_dataset(), topic.get_name(), [item["name"] for item in rs], json.dumps(cfg)) run_id = hashlib.sha224(run_id_string).hexdigest() filename = path.join(self.scores_storage_path, "result-%s.json" % (run_id)) if (os.path.exists(filename) and self.out is None and self.override_results_switch is False): log.info( "Skipping run_id '%s' because the result file does already exist. config: %s" % (run_id, run_id_string)) return else: log.info("Doing %s iterations for run_id '%s'\n %s" % (max_iteration_count, run_id, run_id_string)) write_to_file("", filename) summary, confirmatory_summary, exploratory_summary = sf.run_full_simulation( max_iteration_count=max_iteration_count) recommendations, recom_sentences = sf.get_recommendations() derived_records = [] # construct table-like array of feedbacks per iteration. for i, record in enumerate(sf.flight_recorder.records): for accept in record.accept: derived_records.append({ "iteration": i, "concept": accept, "value": "accept" }) for reject in record.reject: derived_records.append({ "iteration": i, "concept": reject, "value": "reject" }) for implicit_reject in record.implicit_reject: derived_records.append({ "iteration": i, "concept": implicit_reject, "value": "implicit_reject" }) for item in recommendations: derived_records.append({ "iteration": -1, "concept": item, "value": "recommendation", "weight": sf.summarizer.weights.get(item, 0.0), "uncertainity": sf.svm_uncertainity.get(item, -1.0) }) result = { "config_run_id": run_id, "config_oracle_type": oracle, "config_summarizer_type": summarizer, "config_parse_type": str(parser), #"config_wordembeddings": emb_var, "config_feedbackstore": sf.feedbackstore.get_config(), "config_feedback_interpretation": {}, "config_concept_recommendation": {}, "dataset": topic.get_dataset(), "topic": topic.get_name(), "models": rs, "model_rougescores": { "iteration": -1, "ROUGE-1 R score": ub_scores[0], "ROUGE-2 R score": ub_scores[1], "ROUGE-SU* R score": ub_scores[2], "accepted": [], "accept_count": 0, "rejected": [], "reject_count": 0, "summary": ub_summary }, "result_summary": summary, "result_rougescores": sf.log_sir_info_data, "log_feedbacks": derived_records } r2 = [{ "iteration": i, "summary": sf.log_info_data[i] } for i in range(len(sf.flight_recorder.records))] log.debug( "records: %s, infos %s, diff: %s" % (len(sf.flight_recorder.records), len(sf.log_info_data), len(sf.flight_recorder.records) - len(sf.log_info_data))) write_to_file(json.dumps(result), filename) log.info("Writing results to %s" % (filename)) df = pd.DataFrame(derived_records) filename = path.join(self.scores_storage_path, "flightrecorder-%s.csv" % (run_id)) log.info("saving flightrecorder to %s with run_id %s" % (filename, run_id)) df.to_csv(filename, encoding="UTF-8") write_to_file( json.dumps(sf.new_debug_weights_history), path.join( self.scores_storage_path, "weightshistory-%s-%s-%s-%s.json" % (topic.get_dataset(), topic.get_name(), summarizer, run_id))) log.info("Writing weights history to %s" % (filename)) weights_hist = pd.DataFrame(sf.new_debug_weights_history) filename = path.join(self.scores_storage_path, "weightshistory-%s.csv" % (run_id)) weights_hist.to_csv(filename, encoding="UTF-8") log.debug("----------------------------------------------") log.debug(summary) log.debug(sf.log_info_data[-1]) log.debug("----------------------------------------------") if self.pickle_store is not None: # Pickle dictionary using protocol 0. print('Pickle in file %s' % self.pickle_store) self.pickle_write(sf, self.pickle_store, log) json_content = self.write_summarize_output_json( sf, confirmatory_summary, derived_records, log, recom_sentences, result, run_id, summarizer, summary, self.pickle_store) # write_to_file(json_content, path.normpath(path.expanduser(path.join(self.iobasedir, "tmp", "tmp.json")))) else: raise BaseException("You should tell which summarizer to use") if sf is not None: write_details_file([sf.log_info_data], path.join(self.iobasedir, "tmp", "tmp.csv")) self.tlog.debug("SingleTopicRunner finished")
queue = queue[:1] queue = [Summary(i) for i in queue] embeddings_path = path.normpath(path.join(iobasedir, "embeddings")) embeddings = { "english": None, "german": None } for m in queue: t = m.get_topic() i = m.get_index() log("%s - %s" % (t.get_name(), t.get_language())) summary_size = args.summary_size or t.get_summary_size() # parse the feedbackstore arguments fbclass, fbkwargs = get_fbs_args(args) if embeddings[t.get_language()] is None: embeddings[t.get_language()] = load_w2v_embeddings(embeddings_path, t.get_language(), "active_learning") e = embeddings[t.get_language()] fbs = get_fbs(fbclass, fbkwargs, ConceptEmbedder(e), language=t.get_language(), stemmer=SnowballStemmer(t.get_language())) if args.pickleout is not None: pickleout= resolve_filename(args.pickleout.replace("\"","")) else: