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
