def evaluate(model, X_test, best_result, patience, is_test=False): y_pred, y_label = predict(model, X_test) metrics = Metrics(args.score_file_path) with open(args.score_file_path, 'w') as output: for score, label in zip(y_pred, y_label): output.write(str(score) + '\t' + str(label) + '\n') result = metrics.evaluate_all_metrics() if not is_test and result[0] + result[1] + result[2] > best_result[ 0] + best_result[1] + best_result[2]: # tqdm.write("save model!!!") best_result = result tqdm.write("Best Result: R1: %.4f R2: %.4f R5: %.4f" % (best_result[0], best_result[1], best_result[2])) logger.info("Best Result: R1: %.4f R2: %.4f R5: %.4f" % (best_result[0], best_result[1], best_result[2])) model_to_save = model.module if hasattr(model, 'module') else model torch.save(model_to_save.state_dict(), args.save_path) else: patience += 1 if is_test: print("Best Result: R1: %.4f R2: %.4f R5: %.4f" % (best_result[0], best_result[1], best_result[2])) return best_result, patience
def __init__(self, args): super(NeuralNetwork, self).__init__() self.args = args self.patience = 0 self.init_clip_max_norm = 5.0 self.optimizer = None self.best_result = [0, 0, 0, 0, 0, 0] self.metrics = Metrics(self.args.score_file_path) self.device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') config_class, model_class, tokenizer_class = MODEL_CLASSES[args.model_type] self.bert_config = config_class.from_pretrained( args.config_name if args.config_name else args.model_name_or_path, num_labels=1) self.bert_tokenizer = BertTokenizer.from_pretrained( args.tokenizer_name if args.tokenizer_name else args.model_name_or_path, do_lower_case=args.do_lower_case) special_tokens_dict = {'eos_token': '[eos]'} num_added_toks = self.bert_tokenizer.add_special_tokens(special_tokens_dict) self.bert_model = model_class.from_pretrained(args.model_name_or_path, from_tf=bool('.ckpt' in args.model_name_or_path), config=self.bert_config) self.bert_model.resize_token_embeddings(len(self.bert_tokenizer)) self.bert_model = self.bert_model.cuda() '''
class AirMonitorEngine(object): def __init__(self, smog_meter, target, callback, period): self.metrics = Metrics() self.smog_meter = smog_meter self.callback = callback self.last_averages = None self.target = target self._period_minutes = float(period) self._time_of_last_update = time.time() def __del__(self): pass def probe(self): pollutants = self.smog_meter.get_values() if pollutants is None: return self.metrics.add_measurement(pollutants) seconds_in_minute = 60 now = time.time() time_elapsed = (now - self._time_of_last_update) period_seconds = seconds_in_minute * self._period_minutes if time_elapsed > period_seconds: self.last_averages = self.metrics.average() self.target.submit(self.last_averages) self._time_of_last_update = time.time() result = PollutantsResult(pollutants, self.last_averages) self.callback(result)
def main(): # set timer to measure Elapsed Time start_time = time.time() #initializing dataset dataset = DataSet() # Parsing documents dataset.create_document_space() # Printing to output the amount of documents in the document space print("JAVA FILES = ", dataset.get_source_code_list_lenght()) print("BUG REPORTS = ", dataset.get_bug_report_list_lenght()) # Compute all bug reports bug_locator = BugLocalization(dataset) bug_locator.run() # Calculating and printing metrics printing metrics metric = Metrics(dataset) metric.calculate() print("---top_n_rank_list ---") print(dataset.files_pos_ranked) ranks_file.close() # Elapsed Time e = int(time.time() - start_time) print('\nElapsed Time: {:02d}:{:02d}:{:02d}'.format( e // 3600, (e % 3600 // 60), e % 60))
def __init__(self): self.maze = Maze() self.metrics = Metrics() self.size = 25 self.actual_maze = self.maze.generate_actual_maze(self.size) self.start_node_actual, self.goal_node_actual = self.metrics.generate_random_start_and_goal_nodes( self.actual_maze, self.size)
def __init__(self, n_ids, n_track_ids, n_cids): super(Model, self).__init__() self.n_ids = n_ids self.n_track_ids = n_track_ids self.Metrics = Metrics(n_ids, n_track_ids) self.DAE = DAE(n_ids) self.charCNN = CharacterCNN(n_cids, n_ids) self.ff = keras.layers.Dense(n_ids, activation='relu')
def __init__(self): super(NeuralNetwork, self).__init__() self.patience = 0 self.init_clip_max_norm = 2.0# bert adam 에선 전멸임.. self.optimizer = None self.best_result = [0, 0, 0, 0, 0, 0] self.metrics = Metrics(self.args.score_file_path) self.device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
def __init__(self, smog_meter, target, callback, period): self.metrics = Metrics() self.smog_meter = smog_meter self.callback = callback self.last_averages = None self.target = target self._period_minutes = float(period) self._time_of_last_update = time.time()
def analyze_knn(data:List[Point]): N= np.sqrt(len(data)) + 1 numberOfLabels = 2 numberOfNeighbors = 10 numberOfFolds = 10 mumberOfPowers = 3 kernels = KernelType.as_list() coordinateSystems = CoordinateSystem.as_list() stats = [] power = 2 dataCopy = copy.deepcopy(data) trainData, testData = DataAnalyzer.make_cross_validation(dataCopy, numberOfFolds) for numFolds in range(4, numberOfFolds): for numNeighbor in range(3, numberOfNeighbors): #for power in range(2, mumberOfPowers): for coordinateSystem in coordinateSystems: for kernel in kernels: f_scores = [] p_values = [] t_test = "" for i in range(len(trainData)): classifier = KnnClassifier() classifier.train(trainData[i], [0,1],numNeighbor,power,kernel,coordinateSystem) test_item = testData[i] predictions = classifier.predict(test_item) f_score = Metrics.f_score([item.label for item in test_item], predictions) f_scores.append(f_score) p_value = Metrics.p_value([item.label for item in test_item], predictions, 2) p_values.append(p_value[1]) t_test = Metrics.t_test([item.label for item in test_item], predictions) avFscore = DataAnalyzer.calculateAverage(f_scores) stat = Stat(numFolds, numNeighbor, power, kernel, coordinateSystem, avFscore, 0, t_test) #print(stat) stats.append(stat) #print(np.array([str(i) for i in stats]).T) print("KNN ---------------------------------------------------------") print("") print("Max f_score general") print(max(stats, key=lambda x: x.f_score)) print("Max p value general") print(max(stats, key=lambda x: x.p_value)) print("Max t Wilcoxon general") print(max(stats, key=lambda x: x.p_value)) print("") print("KNN ---------------------------------------------------------")
def running_load(self, num_loads=20, load_type="linear"): self.last_load = None ycsb_clients = int(self.utils.ycsb_clients) prev_target = 0 period = num_loads - 1 self.initializeNosqlCluster() self.log_cluster() self.update_hosts() self.init_flavors() # node4 = self.nosqlCluster.cluster.pop("node4") # node3 = self.nosqlCluster.cluster.pop("node3") print("Nodes left in nosqlCluster.cluster:" + str(self.nosqlCluster.cluster)) self.metrics = Metrics() self.ycsb = YCSBController(ycsb_clients) self.time = 0 num_nodes = len(self.nosqlCluster.cluster) if load_type == "sinus": for i in range(num_loads): j = i + 1 target = round(6000 + 3000 * math.sin(2 * math.pi * i / period)) nodes = len(self.nosqlCluster.cluster) meas = self.run_test(target, self.reads) print("\n\nLoad " + str(j)) print("num_nodes = " + str(num_nodes) + ", prev_target = " + str(prev_target) + ", cur_target = " + str(target)) pprint(meas) self.time += 1 prev_target = target print("Letting NoSQL-cluster to rest for 2 mins.") self.sleep(120) elif load_type == "linear": min_load = 16000 dif_load = 0 # TODO to be calculated according to max and min load for i in range(num_loads): j = i + 1 target = min_load + i * dif_load nodes = len(self.nosqlCluster.cluster) meas = self.run_test(target, self.reads) print("\n\nLoad " + str(j)) print("num_nodes = " + str(num_nodes) + ", target = " + str(target)) pprint(meas) self.time += 1 print("Letting NoSQL-cluster to rest for 2 mins.") self.sleep(120)
def __init__(self, hyperparameters: Hyperparameters = Hyperparameters()): super().__init__() self.cells: List[MetaCell] = [] # [NORMAL_CELL, REDUCTION_CELL] self.hyperparameters = hyperparameters self.model_name = 'evo_' + str(time.time()) self.parent_model_name = '' self.metrics = Metrics() self.fitness = 0. self.keras_model: tf.keras.Model = None self.keras_model_data: ModelDataHolder = None
def analyze_svm_one(data:List[Point], kernel = polynomial_kernel, numFolds:int = 4): trainData, testData = DataAnalyzer.make_cross_validation(data, numFolds) stats = [] globalReal= [] globalPredict = [] f_scores = [] p_values = [] t_test = "" for i in range(len(trainData)): x_train = np.array([[item.x, item.y] for item in trainData[i]]) y_train = np.array([-1 if item.label == 0 else 1 for item in trainData[i]]) x_test = np.array([[item.x, item.y] for item in testData[i]]) y_test = np.array([-1 if item.label == 0 else 1 for item in testData[i]]) classifier = SvmClassifier(kernel=kernel) classifier.fit(x_train,y_train) predictions = classifier.predict(x_test) predictions = list(predictions) predictions = [0 if item == -1 else 1 for item in predictions] y_test = [0 if item == -1 else 1 for item in y_test] f_score = Metrics.f_score(y_test, predictions) f_scores.append(f_score) t_test = Metrics.t_test(y_test, predictions) for item in y_test: globalReal.append(item) for item in predictions: globalPredict.append(item) avFscore = DataAnalyzer.calculateAverage(f_scores) stat = StatSvm(numFolds, kernel, avFscore, 0, t_test) #print(stat) stats.append(stat) print("SVM ---------------------------------------------------------") print("") print("Max f_score general") print(max(stats, key=lambda x: x.f_score)) print("Max p value general") print(max(stats, key=lambda x: x.p_value)) print("Max t Wilcoxon general") print(max(stats, key=lambda x: x.p_value)) print("") Metrics.plot_confusion_matrix(globalReal, globalPredict) print("SVM ---------------------------------------------------------") return f_scores, globalPredict
def _getRun(self, functionName, resultName, rank=0.0): results = self.getFunctionResults(functionName, [resultName]) runs = [] pareto = self.getFunctionPareto(functionName) metrics = Metrics(pareto, [results[0][1]]) for run in xrange(len(results[0][1])): metrics.setSolutionsToCompare(0, run, None, None) value = metrics.deltaP() runs.append([value, run]) runs.sort(key = lambda x : x[0]) idx = max(0, int(round(len(runs) * rank)) - 1) return runs[idx][1]
def __init__(self, n_windows=9, margin=100, min_pix=50, poly_margin=100): self.image = None self.last_used_strategy = None self.left_lane = Lane() self.right_lane = Lane() self.metrics = Metrics() # Adjustable parameters for sliding windows: self.sliding_window = SlidingWindowStrategy(n_windows, margin, min_pix) # Parameters for searching around polynomial function: self.poly_search = PolySearchStrategy(poly_margin)
def repeated_algorithm(self): start_node = self.start_node self.w = Metrics().initializeVisuals(7, self.start_node, self.goal_node, self.size, self.actual_maze, self.agent_maze) Metrics().blockage_status_of_children(start_node, self.start_node_actual, self.w) self.goal_node.update_g(float("inf")) lastClosedList = set() while start_node is not self.goal_node: passed = 0 if self.algo_type == 0: passed = SolveMaze().forward_A_star(start_node, self.goal_node, self.agent_maze, self.w) elif self.algo_type == 1: passed = SolveMaze().forward_A_star_in_favor_of_smaller_g( start_node, self.goal_node, self.agent_maze, self.w) elif self.algo_type == 2: passed = SolveMaze().backward_A_star(start_node, self.goal_node, self.agent_maze, self.w) elif self.algo_type == 3: passed = SolveMaze().adaptive_A_star(start_node, self.goal_node, lastClosedList, self.w) if passed == 0: print("I can't reach the target") self.w.noPath() break path, x = Metrics().traverse_path(self.goal_node, start_node, self.algo_type) if self.algo_type == 2: self.w.pathLine(x) else: path.reverse() self.w.pathLine(path) for i in path: if i.cost == self.actual_maze[i.x][i.y].cost: if i in self.solvedMaze: if i in self.solvedMaze: del self.solvedMaze[self.solvedMaze.index(i) + 1:len(self.solvedMaze)] continue self.solvedMaze.append(i) else: start_node = self.solvedMaze.pop() start_node_actual = self.actual_maze[start_node.x][ start_node.y] Metrics().blockage_status_of_children( start_node, start_node_actual, self.w) break if self.solvedMaze[len(self.solvedMaze) - 1] == self.goal_node: print("I reached the goal") self.w.finalPath(self.actual_maze, self.solvedMaze) break mainloop()
def evaluate(self, path, model_path, label, Dict, IMSIZE): model = load_model(model_path) y_pre = [] y_true = [] for root, dirs, files in os.walk(path): for dir in dirs: for root1, dirs1, files1 in os.walk(path + "/" + dir): for file in files1: y_true.append(Dict[dir]) y_pre.append( self.inference_label(model, path + "/" + dir + "/" + file, IMSIZE, label)) me = Metrics(y_pred=y_pre, y_true=y_true) me.evaluate()
def deserialize(self, obj: dict) -> None: # for block in obj['blocks']: # item = MetaCell() # item.deserialize(block) # self.cells.append(item) self.populate_from_embedding(obj['embedding']) self.model_name = obj['model_name'] self.metrics = Metrics() self.metrics.deserialize(obj['metrics']) self.hyperparameters = Hyperparameters() self.hyperparameters.deserialize(obj['hyperparameters']) if 'parent_model_name' in obj: self.parent_model_name = obj['parent_model_name'] else: self.parent_model_name = ''
def main(self): actual_mazes = Maze().readfiftymazes() size = 101 for i in range(50): actual_maze = actual_mazes[i] start_node_actual, goal_node_actual = Metrics().generate_random_start_and_goal_nodes( actual_maze, size) agent_maze = Maze().generate_blank_maze(size) start_node = agent_maze[start_node_actual.x][start_node_actual.y] goal_node = agent_maze[goal_node_actual.x][goal_node_actual.y] RepeatedAlgo(size, actual_maze, agent_maze, start_node, goal_node, start_node_actual, goal_node_actual, 0).repeated_algorithm() agent_maze = Maze().generate_blank_maze(size) start_node = agent_maze[start_node_actual.x][start_node_actual.y] goal_node = agent_maze[goal_node_actual.x][goal_node_actual.y] RepeatedAlgo(size, actual_maze, agent_maze, start_node, goal_node, start_node_actual, goal_node_actual, 1).repeated_algorithm() agent_maze = Maze().generate_blank_maze(size) start_node = agent_maze[start_node_actual.x][start_node_actual.y] goal_node = agent_maze[goal_node_actual.x][goal_node_actual.y] RepeatedAlgo(size, actual_maze, agent_maze, start_node, goal_node, start_node_actual, goal_node_actual, 2).repeated_algorithm() agent_maze = Maze().generate_blank_maze(size) start_node = agent_maze[start_node_actual.x][start_node_actual.y] goal_node = agent_maze[goal_node_actual.x][goal_node_actual.y] RepeatedAlgo(size, actual_maze, agent_maze, start_node, goal_node, start_node_actual, goal_node_actual, 3).repeated_algorithm()
def user(self): user_input = None print("0: Choose maze size, nxn\n" "1: Perform Repeated forward A*\n" "2: Perform Repeated Adaptive A*\n" "q: Quit\n") while user_input != "q": user_input = input("Choose one of the numbers above : ") if user_input == "0": self.size = int(input("Enter the size of the maze, n: ")) self.actual_maze = self.maze.generate_actual_maze(self.size) self.start_node_actual, self.goal_node_actual = Metrics( ).generate_random_start_and_goal_nodes(self.actual_maze, self.size) elif user_input == "1": RepeatedAlgo(self.size, self.actual_maze, self.start_node_actual, self.goal_node_actual, 1).repeated_algorithm() elif user_input == "2": RepeatedAlgo(self.size, self.actual_maze, self.start_node_actual, self.goal_node_actual, 2).repeated_algorithm()
def __init__(self): self.actual_maze = Maze().readfiftymazes()[random.randint(0, 49)] self.blank_maze = None self.size = 101 self.start_node_actual, self.goal_node_actual = Metrics().generate_random_start_and_goal_nodes( self.actual_maze, self.size) self.actual_mazes = Maze().readfiftymazes()
def analyze_knn_one(data:List[Point], kNeighbors:int = 6, kernel:KernelType = KernelType.E, numFolds:int = 4, coordinateSystem:CoordinateSystem = CoordinateSystem.Cartesian): trainData, testData = DataAnalyzer.make_cross_validation(data, numFolds) stats = [] globalReal= [] globalPredict = [] f_scores = [] p_values = [] t_test = "" for i in range(len(trainData)): classifier = KnnClassifier() classifier.train(trainData[i], [0,1],kNeighbors,2,kernel,coordinateSystem) test_item = testData[i] predictions = classifier.predict(test_item) real_data = [item.label for item in test_item] f_score = Metrics.f_score(real_data, predictions) f_scores.append(f_score) p_value = Metrics.p_value(real_data, predictions, 2) p_values.append(p_value[1]) t_test = Metrics.t_test(real_data, predictions) for item in real_data: globalReal.append(item) for item in predictions: globalPredict.append(item) avFscore = DataAnalyzer.calculateAverage(f_scores) stat = Stat(numFolds, kNeighbors, 2, kernel, coordinateSystem, avFscore, 0, t_test) #print(stat) stats.append(stat) #print(np.array([str(i) for i in stats]).T) print("KNN ---------------------------------------------------------") print("") print("Max f_score general") print(max(stats, key=lambda x: x.f_score)) print("Max p value general") print(max(stats, key=lambda x: x.p_value)) print("Max t Wilcoxon general") print(max(stats, key=lambda x: x.p_value)) print("") Metrics.plot_confusion_matrix(globalReal, globalPredict) print("KNN ---------------------------------------------------------") return f_scores, globalPredict
def classify(self, X_train, y_train, X_test, y_test, fold=0): #Make X sparse matrix, y series if isinstance(X_train, DataFrame): X_train = sparse.csr_matrix(X_train) if isinstance(X_test, DataFrame): X_test = sparse.csr_matrix(X_test) if isinstance(y_train, DataFrame): y_train = y_train[0] if isinstance(y_test, DataFrame): y_test = y_test[0] print("Length train: ", len(y_train)) print("Length test: ", len(y_test)) if self.feature_selection: X_train, X_test = self.do_feature_selection( X_train, y_train, X_test) if (self.clf_name == "output_code") or (self.one_vs_all_type == "output_code"): X_train, X_test = X_train.toarray(), X_test.toarray() if (self.clf_name == "gnb") or (self.one_vs_all_type == "gnb"): X_train, X_test = X_train.toarray(), X_test.toarray() self.model.fit(X_train, y_train) self.y_pred = self.model.predict(X_test) print("Num features: ", X_train.shape[1]) #Performance #print("Model score", self.model.score(X_test, y_test)) #same as accuracy print("Accuracy: %.2f%%" % (super().print_accuracy(y_test, self.y_pred))) #Plot feature importance if algorithm supports it #self.plot_feature_importances_big() #Metrics Metrics().print_cl_report(y_test, self.y_pred) #Metrics().conf_matrix(y_test, self.y_pred, title=str(fold), save=True) #Save some metrics self.acc = self.model.score(X_test, y_test) self.cl_report = Metrics().save_cl_report(y_test, self.y_pred) self.f1_score = Metrics().get_f1_score(y_test, self.y_pred)
def __process_evaluated_metric(y1_true, y0_true, y1_hat, y0_hat, ite_dict, true_ITE_list, predicted_ITE_list, ite_csv_path, iter_id): y1_true_np = np.array(y1_true) y0_true_np = np.array(y0_true) y1_hat_np = np.array(y1_hat) y0_hat_np = np.array(y0_hat) PEHE = Metrics.PEHE(y1_true_np, y0_true_np, y1_hat_np, y0_hat_np) ATE = Metrics.ATE(y1_true_np, y0_true_np, y1_hat_np, y0_hat_np) print("PEHE: {0}".format(PEHE)) print("ATE: {0}".format(ATE)) true_ATE = sum(true_ITE_list) / len(true_ITE_list) predicted_ATE = sum(predicted_ITE_list) / len(predicted_ITE_list) Utils.write_to_csv(ite_csv_path.format(iter_id), ite_dict) return PEHE, ATE, true_ATE, predicted_ATE
def init(self, records): # method variables self.last_load = None ycsb_clients = int(self.utils.ycsb_clients) decision_making_file = self.utils.decision_making_file reconfigure = self.utils.reconfigure self.install_logger() # define training_file if os.path.isfile(self.utils.training_file): training_file = self.utils.training_file else: training_file = None # Setting up cluster & parameters self.initializeNosqlCluster() self.log_cluster() self.update_hosts() self.init_flavors() # Preparing to get metrics (termi7 metrics!) self.metrics = Metrics() # Initializing YCSB self.ycsb = YCSBController(ycsb_clients) # Setting up Decision Making self.decision_maker = DecisionMaking.DecisionMaker( decision_making_file, training_file) self.setting_up_dec_maker() # More configurations... self.decision_maker.train( ) # If training file is not valid file, DecisionMaker makes it None and training is aborted. # Usually reconfigure = False if eval(reconfigure): self.nosqlCluster.init_ganglia() self.my_logger.debug("Waiting for HBase to get ready ... ") self.sleep(30) self.nosqlCluster.init_db_table() self.my_logger.debug("Will start loading data in 120 seconds.") self.sleep(120) self.ycsb.load_data(records, verbose=True) self.sleep(240) self.my_logger.debug( "END of Tiramola pseudo-__init__(). Next step... run_warm_up(?).\n" )
def __init__(self, args): super(NeuralNetwork, self).__init__() self.args = args self.patience = 0 self.init_clip_max_norm = 5.0 self.optimizer = None self.best_result = [0, 0, 0, 0, 0, 0] self.metrics = Metrics(self.args.score_file_path) self.device = torch.device( 'cuda:0' if torch.cuda.is_available() else 'cpu') config_class, model_class, tokenizer_class = MODEL_CLASSES[ args.model_type] self.bert_config = config_class.from_pretrained( args.config_name if args.config_name else args.model_name_or_path, finetuning_task="classification", num_labels=1) self.bert_tokenizer = BertTokenizer.from_pretrained( args.tokenizer_name if args.tokenizer_name else args.model_name_or_path, do_lower_case=args.do_lower_case) special_tokens_dict = { 'eos_token': '[eos]', 'additional_special_tokens': ['[soe]', '[eoe]'] } num_added_toks = self.bert_tokenizer.add_special_tokens( special_tokens_dict) self.bert_model = model_class.from_pretrained( args.model_name_or_path, from_tf=bool('.ckpt' in args.model_name_or_path), config=self.bert_config) self.bert_model.resize_token_embeddings(len(self.bert_tokenizer)) self.bert_model = self.bert_model.cuda() self.attn = nn.Linear(768, 768) self.rnn = nn.GRU(input_size=768, hidden_size=200, num_layers=1, batch_first=True, bidirectional=False) self.bilinear = nn.Bilinear(768, 768, 1)
def __init__(self, size, actual_maze, start_node_actual, goal_node_actual, algo_type): self.size = size self.actual_maze = actual_maze self.start_node_actual = start_node_actual self.goal_node_actual = goal_node_actual self.algo_type = algo_type self.agent_maze = Maze().generate_blank_maze(self.size) self.start_node = self.agent_maze[self.start_node_actual.x][ self.start_node_actual.y] self.goal_node = self.agent_maze[self.goal_node_actual.x][ self.goal_node_actual.y] self.solvedMaze = [] self.w = Metrics().initializeVisuals(self.start_node, self.goal_node, self.size, self.actual_maze, self.agent_maze)
def __init__(self,args): super(NeuralNetwork, self).__init__() self.args = args self.patience = 0 self.init_clip_max_norm = 5.0 self.optimizer = None self.best_result = [0, 0, 0, 0, 0, 0] self.metrics = Metrics(self.args.score_file_path) self.device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') config_class, model_class, tokenizer_class = MODEL_CLASSES[args.model_type] self.bert_config = config_class.from_pretrained( args.config_name if args.config_name else args.model_name_or_path, finetuning_task="classification", num_labels=1) self.bert_tokenizer = BertTokenizer.from_pretrained( args.tokenizer_name if args.tokenizer_name else args.model_name_or_path, do_lower_case=args.do_lower_case) special_tokens_dict = {'eos_token': '[eos]'} num_added_toks = self.bert_tokenizer.add_special_tokens(special_tokens_dict) self.bert_model = model_class.from_pretrained(args.model_name_or_path, from_tf=bool('.ckpt' in args.model_name_or_path), config=self.bert_config) self.bert_model.resize_token_embeddings(len(self.bert_tokenizer)) self.bert_model = self.bert_model.cuda() # multihop self._attention = SoftmaxAttention() self._projection = nn.Sequential(nn.Linear(4 * 768,200),nn.ReLU()) self.rnn2=nn.GRU( input_size=200, hidden_size=200, num_layers=1, batch_first=True, bidirectional=True ) self._classification = nn.Sequential(nn.Dropout(p=0.2), nn.Linear(2 * 6 *200, 200), nn.Tanh(), nn.Dropout(p=0.2), nn.Linear(200,1))
def __init__(self, adjustment=None): gtk.Widget.__init__(self) self.set_flags(gtk.CAN_FOCUS) self.offscreen_pixmap = None self.palette = {} self.gc = {} self.cursor = gtk.gdk.Cursor(gtk.gdk.CROSS) context = self.create_pango_context() desc = context.get_font_description() desc.set_family("monospace") desc.set_absolute_size(12 * pango.SCALE) self.layout12 = pango.Layout(context) desc.set_absolute_size(10 * pango.SCALE) self.layout10 = pango.Layout(context) desc.set_absolute_size(9 * pango.SCALE) self.layout9 = pango.Layout(context) self.metrics = Metrics(self.layout10) self.adjustment = None self.handler_id_changed = -1 self.handler_id_value_changed = -1 self.player = Player(self) self.audiofile = "" self.caps = None self.data = array.array("b") self.loader_thread_id = -1 self.fr_cut_in = 0 self.fr_cut_out = 8000 * 60 self.x_cue_pos = -1 self.draw_solid = True self.draw_buf = {0: []} self.playback_status = (False, 0) if not adjustment: adjustment = gtk.Adjustment(0, 0, 8000 * 60, page_size=8000 * 60) self.set_adjustment(adjustment)
def get_callbacks(filename): metrics = Metrics() callbacks = [ ModelCheckpoint(filename, monitor='val_loss', save_best_only=True, mode='min'), EarlyStopping(monitor='val_loss', patience=5), metrics ] return callbacks
def evaluate(self, n_folds=10): matrices = [] f1 = 0 precision = 0 recall = 0 for train, test in self.__dp.split(n_folds, ActivityDataHeaders.START_TIME): self.fit(train) processed_dataset = self.process_dataset(test) predictions = self.__predict(processed_dataset) metric = Metrics(processed_dataset[ActivityDataHeaders.LABEL], pd.DataFrame(predictions)) f1 += metric.f1() precision += metric.precision() recall += metric.recall() matrices += [metric.confusion_matrix()] f1 /= n_folds precision /= n_folds recall /= n_folds matrices = np.array(matrices) return f1, precision, recall, matrices
class Searcher: def __init__(self, raw_documents): self.corpus = Corpus(raw_documents) self.metrics = Metrics(self.corpus) def search(self, query): results = [] query_document = Document(query) query_stems = query_document.get_stems() documents = self.corpus.get_documents() for doc in documents: document_id = doc.get_id() score = 0.0 stemmed_document = doc.get_stems() for qstem in query_stems: if qstem in stemmed_document: term_frequency = self.metrics.get_term_frequency(document_id, qstem) score += term_frequency if score > 0.0: results.append({"id": doc.get_id(), "score": score, "text": doc.get_text()}) return results def get_corpus(self): return self.corpus
def __init__(self, raw_documents): self.corpus = Corpus(raw_documents) self.metrics = Metrics(self.corpus)
def computeMetrics(self, optimalPareto, solutions, functionName): self.solutionNames = [solution[0] for solution in solutions] solutionData = [solution[1] for solution in solutions] # solutionData = self._removeDominatedFromSolutionData([solution[1] for solution in solutions]) self.dim = len(solutionData[0][0][0]) self.nSolutions = len(self.solutionNames) metrics = Metrics(optimalPareto, solutionData) self.unaryMetricNames = ["Inverted Generational Distance", "Delta P", "Spacing", "Hypervolume"] self.unaryMetricOptType = [MetricsCalc.__MIN__, MetricsCalc.__MIN__, MetricsCalc.__MIN__, MetricsCalc.__MAX__] unaryMetricType = [ MetricsCalc.__CONV__, MetricsCalc.__CONV__, MetricsCalc.__DIST__, [MetricsCalc.__CONV__, MetricsCalc.__DIST__], ] unaryMetricFunction = [ metrics.invertedGenerationalDistance, metrics.deltaP, metrics.spacing, metrics.hypervolume, ] self.nUnaryMetrics = len(self.unaryMetricNames) self.binaryMetricNames = ["Coverage", "Additive Epsilon", "Multiplicative Epsilon"] self.binaryMetricOptType = [MetricsCalc.__MAX__, MetricsCalc.__MIN__, MetricsCalc.__MIN__] binaryMetricType = [MetricsCalc.__CONV__, MetricsCalc.__CONV__, MetricsCalc.__CONV__] self.nBinaryMetrics = len(self.binaryMetricNames) self.labels = [] self.sublabels = [] self.labels += self.unaryMetricNames self.sublabels += [None] * len(self.labels) for binaryMetric in self.binaryMetricNames: self.labels += [binaryMetric] * self.nSolutions self.sublabels += self.solutionNames self.labels.append("Points") self.sublabels.append("Convergence") self.labels.append("Points") self.sublabels.append("Distribution") nLabels = len(self.labels) self.metricMean = [[None] * (self.nSolutions) for _ in xrange(nLabels)] self.metricStd = [[None] * (self.nSolutions) for _ in xrange(nLabels)] self.metricMin = [[None] * (self.nSolutions) for _ in xrange(nLabels)] self.metricMax = [[None] * (self.nSolutions) for _ in xrange(nLabels)] self.metricQ1 = [[None] * (self.nSolutions) for _ in xrange(nLabels)] self.metricQ3 = [[None] * (self.nSolutions) for _ in xrange(nLabels)] self.metricIsBest = [[False] * (self.nSolutions) for _ in xrange(nLabels)] nadirPoint = [-(1 << 30)] * self.dim for solution in solutionData: r = 0 for run in solution: r += 1 for point in run: for d in xrange(self.dim): nadirPoint[d] = max(nadirPoint[d], math.ceil(point[d] * 10 + 0.001) / 10.0) print " Using Nadir point: " + str(nadirPoint) metrics.setHypervolumeReference(nadirPoint) maxHypervolume = metrics.maxHypervolume() mean = Utils.createListList(self.nUnaryMetrics) std = Utils.createListList(self.nUnaryMetrics) mmin = Utils.createListList(self.nUnaryMetrics) mmax = Utils.createListList(self.nUnaryMetrics) q1 = Utils.createListList(self.nUnaryMetrics) q3 = Utils.createListList(self.nUnaryMetrics) for solutionA in xrange(self.nSolutions): values = Utils.createListList(self.nUnaryMetrics) for runA in xrange(len(solutionData[solutionA])): metrics.setSolutionsToCompare(solutionA, runA, None, None) for i in xrange(self.nUnaryMetrics): value = unaryMetricFunction[i]() if math.isnan(value): if self.unaryMetricNames[i] != "Spacing": print >> sys.stderr, "Found one metric, besides Spacing, giving NaN: %s" % ( self.unaryMetricNames[i] ) else: # Good value if self.unaryMetricNames[i] == "Hypervolume": value /= maxHypervolume if value > 1: # print >> sys.stderr, " Normalized hypervolume of %s for %s exceeds 1.0: %f" % \ # (self.solutionNames[solutionA], functionName, value) value = 1.0 values[i].append(value) for m in xrange(len(values)): mean[m].append(numpy.mean(values[m])) std[m].append(numpy.std(values[m])) mmin[m].append(numpy.min(values[m])) mmax[m].append(numpy.max(values[m])) q1[m].append(scoreatpercentile(values[m], 25)) q3[m].append(scoreatpercentile(values[m], 75)) for metric in [MetricsCalc.COVERAGE, MetricsCalc.ADDITIVE_EPSILON, MetricsCalc.MULTIPLICATIVE_EPSILON]: meanMetric, stdMetric = self._getMetric(solutionData, metric, metrics, self.solutionNames) mean += meanMetric std += stdMetric self.convPoints = [0] * self.nSolutions self.distPoints = [0] * self.nSolutions for row in xrange(len(mean)): for column in xrange(len(mean[row])): m = mean[row][column] s = std[row][column] if m is None or s is None: continue if row < len(self.unaryMetricNames): factor = self.unaryMetricOptType[row] if ( abs( round(m * factor, Utils.__ROUND__) - round(min(x * factor for x in mean[row] if x is not None), Utils.__ROUND__) ) < Utils.__EPS__ ): self.metricIsBest[row][column] = True for i in xrange(len(mean[row])): if ( i != column and mean[row][i] is not None and round(mean[row][column] * factor, Utils.__ROUND__) <= round(mean[row][i] * factor, Utils.__ROUND__) ): self._addMetricPoints(1.0 / (self.nSolutions - 1), column, unaryMetricType[row]) elif row >= len(self.unaryMetricNames): offset = row - (row - len(self.unaryMetricNames)) % self.nSolutions metricIdx = int((row - len(self.unaryMetricNames)) / self.nSolutions) factor = self.binaryMetricOptType[metricIdx] if round(m * factor, Utils.__ROUND__) >= round( mean[offset + column][row - offset] * factor, Utils.__ROUND__ ): self.metricIsBest[row][column] = True self._addMetricPoints(1.0 / (self.nSolutions - 1), column, binaryMetricType[metricIdx]) self.metricMean[row][column] = m self.metricStd[row][column] = s if row < len(self.unaryMetricNames): self.metricMin[row][column] = mmin[row][column] self.metricMax[row][column] = mmax[row][column] self.metricQ1[row][column] = q1[row][column] self.metricQ3[row][column] = q3[row][column] row = nLabels - 2 for points in [self.convPoints, self.distPoints]: maxValue = max(points) for solutionIdx in xrange(self.nSolutions): value = points[solutionIdx] if abs(value - maxValue) < Utils.__EPS__: self.metricIsBest[row][solutionIdx] = True self.metricMean[row][solutionIdx] = value row += 1