def submit(request, id): # if this page was tried to access while submitting a form (adding submission to a problem) if request.method == 'POST': form = SubmitSolutionForm(request.POST, request.FILES) filename = request.FILES['submission_code'].name # If the file is not cpp/python if not filename.endswith('.cpp') and not filename.endswith('.py'): messages.error(request, 'Wrong file type') elif form.is_valid(): # create and instance of form but don't save it form = form.save(commit=False) form.author = request.user form.problem_code = problem.objects.get(id=id) form.save() cur_user = request.user cur_user.profile.problems_tried += 1 cur_prob = problem.objects.get(id=id) cur_prob.total_submissions += 1 verdict = evaluate(form.submission_code, id) if verdict == 'AC': cur_user.profile.problems_solved += 1 cur_prob.successful_submissions += 1 cur_prob.save() cur_user.profile.save() # print(request.user, '=================================================',cur_user.profile.problems_tried) # update all fields of question and user submissions messages.success(request, 'Added submission') else: messages.error(request, 'cant add submission') return render(request, 'problems/add_submission.html', {'form': SubmitSolutionForm()})
def train(args): # Get model model = models.__dict__[args.model](args) if args.ckpt_path: model = ModelSaver.load_model(model, args.ckpt_path, args.gpu_ids, is_training=True) model = model.to(args.device) model.train() # Get loader, logger, and saver train_loader, val_loader = get_data_loaders(args) logger = TrainLogger(args, model, dataset_len=len(train_loader.dataset)) saver = ModelSaver(args.save_dir, args.max_ckpts, metric_name=args.metric_name, maximize_metric=args.maximize_metric, keep_topk=True) # Train while not logger.is_finished_training(): logger.start_epoch() for batch in train_loader: logger.start_iter() # Train over one batch model.set_inputs(batch['src'], batch['tgt']) model.train_iter() logger.end_iter() # Evaluate if logger.global_step % args.iters_per_eval < args.batch_size: criteria = {'MSE_src2tgt': mse, 'MSE_tgt2src': mse} stats = evaluate(model, val_loader, criteria) logger.log_scalars({'val_' + k: v for k, v in stats.items()}) saver.save(logger.global_step, model, stats[args.metric_name], args.device) logger.end_epoch()
def act(self, state: np.ndarray): self.simulation_env.reset(state, self.player) valid_actions = self.simulation_env.get_valid_actions().nonzero()[0] values = np.zeros_like(valid_actions, dtype=np.float) for idx, action in enumerate(valid_actions): self.simulation_env.step(action) next_state = self.simulation_env.get_state() value = evaluate(next_state) # Multiply with self.player (-1 or 1) so we can always choose the argmax values[idx] = value * self.player self.simulation_env.reset(state, self.player) return valid_actions[np.argmax(values)]
def do_evaluate(args): from evaluation.evaluate import parse_file, evaluate, evaluate_output, print_results, print_relevant variables = parse_file(args.file) if args.print_relevant: print_relevant(**variables) else: if args.multisearch_result: # Skip the query-running step with open(args.multisearch_result) as fp: output = fp.read() results = evaluate_output(output, **variables) else: # Run the queries results = evaluate(**variables) print_results(results, args.format)
def postprocessing_with_evaluation_block1(x_test, y_test, timepoints, test_file_list, x_challenge, challenge_file_list, model, param): """Post processes test and challenge files. Evaluates new PSDS on test set and returns post processed test and prediction data """ prediction = model.predict(x_test) challenge_prediction = model.predict(x_challenge) if param['post_processing'] == 'no': print('No post processing used') return prediction, challenge_prediction elif param['post_processing'] == 'fill': print('Filling post processing used.') timethres = param['post_timethres'] noisethres = param['post_noisethres'] base = param['post_base'] post_processed_test = np.array([ postProcess(pred, timepoints, timeThresh=timethres, noiseThresh=noisethres, base=base) for pred in prediction ]) post_processed_prediction = np.array([ postProcess(pred, timepoints, timeThresh=timethres, noiseThresh=noisethres, base=base) for pred in challenge_prediction ]) plot_confusion_matrix(y_test, post_processed_test) # calculate psds for test set df_test_pred = getPredictionAsSequenceDF(post_processed_test, timepoints, test_file_list) pred_csv_path = param['prediction_path'] + 'test_pred_postprocessed.csv' df_test_pred.to_csv(pred_csv_path, index=False) #dev_csv_path = param['data_folder'] + param['dev_csv'] #dev_df = pd.read_csv(dev_csv_path, header=0, usecols=[0, 1, 2, 3]) #test_df = dev_df[dev_df.filename.isin(test_file_list)] test_csv_path = param['prediction_path'] + 'test_ref_current.csv' post_processed_psds_info = evaluate.evaluate(pred_csv_path, test_csv_path) print('PSDS', post_processed_psds_info) return post_processed_test, post_processed_prediction, post_processed_psds_info[ 0]
def evaluation_block1(X_test, Y_test, timepoints, testFileList, model, eval_param): """Evaluates current model on test data from dev set. Also calculates PSDS score.""" prediction = model.predict(X_test) scores_list = model.evaluate(X_test, Y_test) print('') print('Evaluation:') print('Loss, MAE, Accuracy', scores_list) plot_confusion_matrix(Y_test, prediction) prediction_df = getPredictionAsSequenceDF(prediction, timepoints, testFileList) pred_csv_path = eval_param['prediction_path'] + 'test_pred_model.csv' prediction_df.to_csv(pred_csv_path, index=False) #dev_csv_path = eval_param['data_folder'] + eval_param['dev_csv'] #dev_df = pd.read_csv(dev_csv_path, header=0, usecols=[0, 1, 2, 3]) #test_df = dev_df[dev_df.filename.isin(testFileList)] test_csv_path = eval_param['prediction_path'] + 'test_ref_current.csv' psds_info = evaluate.evaluate(pred_csv_path, test_csv_path) print('PSDS', psds_info) print('') return scores_list, psds_info[0]
import sys sys.path.append('../') import logging import time from evaluation.evaluate import evaluate if __name__ == '__main__': logger = logging.getLogger('signature') logfile = '../../data/log/%d_learnSMF.log'%int(time.time()) logging.basicConfig(filename = logfile, format='%(asctime)s : %(name)-12s: %(levelname)s : %(message)s') logging.root.setLevel(level=logging.DEBUG) logger.info("running %s" % ' '.join(sys.argv)) console = logging.StreamHandler() console.setLevel(logging.DEBUG) # set a format which is simpler for console use formatter = logging.Formatter('%(asctime)s : %(name)-12s: %(levelname)-8s %(message)s') # tell the handler to use this format console.setFormatter(formatter) logger.addHandler(console) #path = '../../data/restaurants/' path = '../../data/beautyspa/' evaluate(path)
for threshold2 in [0.72]: with Timer('Second step'): edges_new = [] edges = np.array(edges) share_num = common_link[ edges[:, 0].tolist(), edges[:, 1].tolist()].tolist()[0] edges = edges.tolist() for i in range(len(edges)): if ((link_num[edges[i][0]]) != 0) & ( (link_num[edges[i][1]]) != 0): if max((share_num[i]) / link_num[edges[i][0]], (share_num[i]) / link_num[edges[i][1]]) > threshold2: edges_new.append(edges[i]) if i % 10000000 == 0: print(i) with Timer('Last step'): pre_labels = edge_to_connected_graph( edges_new, 584013) gt_labels = np.load('./pretrained_model/gt_labels.npy') print('the threshold1 is:{}'.format(threshold1)) print('the threshold2 is:{}'.format(threshold2)) evaluate(gt_labels, pre_labels, 'pairwise') evaluate(gt_labels, pre_labels, 'bcubed') evaluate(gt_labels, pre_labels, 'nmi')
import sys sys.path.append("../") import logging import time from evaluation.evaluate import evaluate from params.params import path if __name__ == "__main__": logger = logging.getLogger("signature") logfile = "../../data/log/%d_learnSMF.log" % int(time.time()) logging.basicConfig(filename=logfile, format="%(asctime)s : %(name)-12s: %(levelname)s : %(message)s") logging.root.setLevel(level=logging.DEBUG) logger.info("running %s" % " ".join(sys.argv)) console = logging.StreamHandler() console.setLevel(logging.DEBUG) # set a format which is simpler for console use formatter = logging.Formatter("%(asctime)s : %(name)-12s: %(levelname)-8s %(message)s") # tell the handler to use this format console.setFormatter(formatter) logger.addHandler(console) evaluate(path, userProfileThres=5)