def getFitness(self, matrix): ev1_1 = ev.Evaluator(1, matrix) ev2_1 = ev.Evaluator(2) ag1_1 = ag.AlphaBetaAgent(1, 2, ev1_1) ag2_1 = ag.AlphaBetaAgent(2, 2, ev2_1) result1, game1 = self.simulateGame(ag1_1, ag2_1) white, black = game1.countColors() if black == 0: fitness1 = 64 elif white == 0: fitness1 = -64 else: fitness1 = white - black ev1_2 = ev.Evaluator(1, matrix) ev2_2 = ev.Evaluator(2) ag2_2 = ag.AlphaBetaAgent(1, 2, ev2_2) ag1_2 = ag.AlphaBetaAgent(2, 2, ev1_2) result2, game2 = self.simulateGame(ag2_2, ag1_2) white, black = game2.countColors() if black == 0: fitness2 = -64 elif white == 0: fitness2 = 64 else: fitness2 = black - white fitness = (fitness1 + fitness2) return fitness
def simulateAlpha(): ev1 = ev.Evaluator(1) ev2 = ev.Evaluator(1) """#Alfabeta vs Union ag1 = ag.AlphaBetaAgent(1,4,ev1) ag2 = ag.UnionRulesAgent(2) sim = Simulation(ag1, ag2, 250, 1) # Union vs Alfabeta ag1 = ag.UnionRulesAgent(1) ag2 = ag.AlphaBetaAgent(2,4,ev1) sim = Simulation(ag1, ag2, 250, None, 1)""" # Determinista # Alfabeta vs Minimax ag1 = ag.AlphaBetaAgent(1, 4, ev1) ag2 = ag.MinimaxAgent(2, 4, ev2) sim = Simulation(ag1, ag2, 1, 1, 1) # Minimax vs Alfabeta ag1 = ag.MinimaxAgent(1, 4, ev2) ag2 = ag.AlphabetaAgent(2, 4, ev1) sim = Simulation(ag1, ag2, 1, 1, 1) #Alfabeta vs MCTS ag1 = ag.AlphaBetaAgent(1, 4, ev1) ag2 = ag.MonteCarloAgent(2, None) sim = Simulation(ag1, ag2, 250, 1) # MCTS vs Alfabeta ag1 = ag.MonteCarloAgent(1, None) ag2 = ag.AlphaBetaAgent(2, 4, ev1) sim = Simulation(ag1, ag2, 250, None, 1)
def simulateEvaluator(): # Alfabeta vs alfabeta variando evaluator for i in range(1, 7): for j in range(1, 7): if i != j: sim = Simulation(ag.AlphaBetaAgent(1, 4, ev.Evaluator(i)), ag.AlphaBetaAgent(2, 4, ev.Evaluator(j)), 1, i, j)
def simulateBestAlphaModifyDepth(evaluator): ev1 = ev.Evaluator(evaluator) ev2 = ev.Evaluator(evaluator) # Deterministas #Alfabeta vs minimax for i in range(1, 3): ag1 = ag.MinimaxAgent(1, i, ev1) ag2 = ag.MinimaxAgent(1, 4, ev2) sim = Simulation(ag1, ag2, 1, evaluator, evaluator)
def simulateDepthM(): ev1 = ev.Evaluator(1) ev2 = ev.Evaluator(1) for i in range(1, 9): sim = Simulation(ag.MinimaxAgent(1, i, ev1), ag.AlphaBetaAgent(2, 4, ev2), 1, "", 1) sim = Simulation(ag.AlphaBetaAgent(1, 4, ev2), ag.MinimaxAgent(2, i, ev1), 1, 1, "")
def calc_map(self, gt, iou_thresh: float=0.25, ignore_grade: bool=False): boundingBoxes = self._extract_bounding_boxes(gt, ignore_grade) evaluator = Evaluator() metricsPerClass = evaluator.GetPascalVOCMetrics(boundingBoxes, iou_thresh) return np.mean([np.nan_to_num(mc['AP']) for mc in metricsPerClass])
def tuneConfidenceBaseBid(self, testDF): print("Setting up XGBoost for Test set") y_pred = self.__estimateClick(testDF) y_pred = [1 if i >= 0.7 else 0 for i in y_pred] # print("number of 1 here: ", sum(y_pred)) # avgCTR = np.count_nonzero(testDF.click) / testDF.shape[0] myEvaluator = Evaluator.Evaluator() bestCTR = -1 bestBidPrice = -1 for i in range(300, 301): bidprice = BidEstimator().confidenceBidPrice(y_pred, -1, i) # print("total bid price: ", sum(bidprice)) # print("total bid submitted: ", np.count_nonzero(bidprice)) # print("Number of $0 bid", bidprice.count(0)) bids = np.stack([testDF['bidid'], bidprice], axis=1) bids = pd.DataFrame(bids, columns=['bidid', 'bidprice']) # print("Estimated bid price: ", bids.bidprice.ix[0]) resultDict = myEvaluator.computePerformanceMetricsDF(6250 * 1000, bids, validateDF) myEvaluator.printResult() ctr = resultDict['click'] / resultDict['won'] if ctr > bestCTR: bestCTR = ctr bestBidPrice = i print("Best CTR: %.5f \nPrice: %d" % (bestCTR, bestBidPrice))
def run(): f = open('./config.yml') config = yaml.load(f) roi_shape = config['roi_shape'] dead_zone = config['dead_zone'] cube_resolution = config['cube_resolution'] laser_num = config['laser_num'] lidar_num = config['lidar_num'] beam_angle = config['beam_angle'] max_itrs = config['max_itrs'] numb_bees = config['numb_bees'] lower_bound = config['lower_bound'] * lidar_num upper_bound = config['upper_bound'] * lidar_num estimate_solve_time = config['estimate_solve_time'] save_result_to_json = config['save_result_to_json'] assert (len(beam_angle) == laser_num ), "Please check the number of beams' angles of pitch" eval.logConfig(config=config) VSR_solver = eval.Evaluator(roi_shape=roi_shape, dead_zone=dead_zone, cube_resolution=cube_resolution, laser_num=laser_num, lidar_num=lidar_num, pitch_angle=beam_angle) now = time.time() for i in range(max_itrs): VSR_solver.solve(lower_bound) total_time = time.time() - now print("Average time consume: ", total_time / max_itrs)
def __init__(self, sparql=None, compiler=None, evaluator=None, multiline_parser=None, options=['time'], debug=False, load_translations=True): self.sparql = sparql if self.sparql: self.n = sparql.n else: self.n = Namespaces.Namespaces() # self.translator = translator if compiler: self.compiler = compiler else: self.compiler = Compiler.Compiler(self.n) if evaluator == None: evaluator = Evaluator.Evaluator(self.n) self.evaluator = evaluator self.parser = Parser.Parser(self.n) self.urigen = UniqueURIGenerator() if multiline_parser == None: multiline_parser = MultilineParser.MultilineParser(self.n, self) self.multiline_parser = multiline_parser self.options = options self.cum_comp_time = 0 self.cum_eval_time = 0 if not debug: self.compiler.debug_off() if load_translations: from loadTranslations import loadTranslations loadTranslations(self)
def exeLogisticRegressionBidModel_v2(validationReader=None, trainReader=None, writeResult2CSV=False): print("============ LogisticRegressionBidModel_v2") trainOneHotData, trainY = trainReader.getOneHotData() validationOneHotData, valY = validationReader.getOneHotData( train_cols=trainOneHotData.columns.get_values().tolist()) X_train = trainOneHotData Y_train = trainY['click'] X_val = validationOneHotData Y_val = valY['click'] lbm = LinearBidModel_v2(cBudget=110, avgCTR=0.2) lbm.trainModel(X_train, Y_train) # lbm.gridSearchandCrossValidate(X_train, Y_train) # print (validationReader.getDataFrame().info()) v_df = validationReader.getDataFrame() y_pred, bids = lbm.getBidPrice(X_val, v_df) if writeResult2CSV: ipinyouWriter.ResultWriter().writeResult("resultLogisticRegressionBidModel.csv", bids) myEvaluator = Evaluator() myEvaluator.computePerformanceMetricsDF(6250 * 1000, bids, v_df) myEvaluator.printResult() return y_pred
def __init__(self): self.nmoves = 1 # Menu para elegir a los jugadores self.menu = Interface.Menu() self.playerBlack, self.playerWhite = self.menu.returnPlayers() self.evaluator1 = ev.Evaluator(1) self.evaluator2 = ev.Evaluator(1) self.selectPlayers() self.board = Interface.Board() # Crea el juego self.game = gr.Othello() self.startGame()
def exeEnsemble_v1(trainDF, targetDF, trainPath, validationPath, targetPath, writeResult2CSV=False): xg_y_pred = exeXGBoostBidModel(validationData=targetDF, trainData=trainDF, writeResult2CSV=False) cnn_y_pred = exeCNNBidModel(validationDataPath=validationPath, trainDataPath=trainset, testDataPath=targetPath, writeResult2CSV=False) # fm_y_pred = exeFM_SGDBidModel(validationDataOneHot=validateDFonehot, trainDataOneHot=trainDFonehot, validationData=validateDF, writeResult2CSV=True) # Use XG's 0 when its threshold is below 0.75. y_pred = [0 if xg < 0.75 else cnn for xg, cnn in zip(xg_y_pred, cnn_y_pred)] # Use CNN's 1 when its threshold is above 0.2? prune_thresh = 0.2 be = BidEstimator() bidprice = be.linearBidPrice_mConfi(y_pred, 230, 100, prune_thresh) # bidprice = be.linearBidPrice_variation(y_pred, 80, 0.2, slotprices=slotprices, prune_thresh=prune_thresh) bids = np.stack([targetDF['bidid'], bidprice], axis=1) bids = pd.DataFrame(bids, columns=['bidid', 'bidprice']) if writeResult2CSV: ipinyouWriter.ResultWriter().writeResult("resultEnsemble_v1.csv", bids) myEvaluator = Evaluator.Evaluator() myEvaluator.computePerformanceMetricsDF(6250*1000, bids, targetDF) # Force CNN result to 1 and 0 for F1 score y_pred = [1 if i >= prune_thresh else 0 for i in y_pred] ce = Evaluator.ClickEvaluator() ce.printClickPredictionScore(y_pred, targetDF)
def main(args): print(args) settings = Settings.Settings(args) # We already did these # ResNet50 and indices: 5, 2, 7, 3 (doing ? r.n.) settings.TestDataset_Fold_Index = int(args.FOLD_I) # can be 0 to 9 (K-1) settings.TestDataset_K_Folds = int(args.KFOLDS) assert settings.TestDataset_Fold_Index < settings.TestDataset_K_Folds kfold_txt = "KFold_" + str(settings.TestDataset_Fold_Index) + "z" + str( settings.TestDataset_K_Folds) print(kfold_txt) settings.model_backend = args.model_backend settings.train_epochs = int(args.train_epochs) settings.train_batch = int(args.train_batch) # resnet 101 approx 5-6 hours (per fold - might be a bit less ...) # resnet 50 approx 3-4 hours model_txt = "cleanManual_" + str( settings.train_epochs) + "ep_ImagenetWgenetW_" + str( settings.model_backend) + "-" + str( settings.train_batch ) + "batch_Augmentation1to1_ClassWeights1to3_TestVal" print(model_txt) dataset = Dataset.Dataset(settings) evaluator = Evaluator.Evaluator(settings) #settings.run_name = settings.run_name + "AYRAN" show = False save = True #dataset.dataset model = ModelHandler.ModelHandler(settings, dataset) if not os.path.exists("plots/"): os.makedirs("plots/") model.model.train(show=show, save=save) # K-Fold_Crossval: model.model.save( "/scratch/ruzicka/python_projects_large/ChangeDetectionProject_files/weightsModel2_" + model_txt + "_[" + kfold_txt + "].h5") SAVE_ALL_FOLDER = model_txt + "PLOTS/" SAVE_ALL_PLOTS = SAVE_ALL_FOLDER + "plot" # DEBUG_SAVE_ALL_THR_PLOTS = None if not os.path.exists(SAVE_ALL_FOLDER): os.makedirs(SAVE_ALL_FOLDER) evaluator.unified_test_report([model.model.model], dataset.test, validation_set=dataset.val, postprocessor=model.model.dataPreprocesser, name=SAVE_ALL_PLOTS, optionally_save_missclassified=True)
def evaluate(): st = StanfordNERTagger(model, jar, encoding='utf-8') ev = Evaluator.Evaluator() for i in range(1, 301): print("File " + str(i)) e = evaluateMeasure( dataDir + "\\seminars_training\\training\\{}.txt".format(i), ev, i) e.evalResults()
class Simpson13: evaluator = Evaluator.Evaluator() def simpson13(self, a, b): h = float((b - a))/2 x1 = a + h fa = self.evaluator.evaluate(funtion, a) fb = self.evaluator.evaluate(funtion, b) fx1 = self.evaluator.evaluate(funtion, x1) w = ((float(h) / 3) * (fa + (4 * fx1) + fb)) print "El resultado sin restar el error es: ", w
class ReglaSimpleTrapecio: evaluator = Evaluator.Evaluator() def simpleTrapecio(self, a, b): x = sympy.symbols('x') f = sympy.exp(x) - 2 * x h = b - a fa = self.evaluator.evaluate(f, a) fb = self.evaluator.evaluate(f, b) print(float(h) / 2) * (fa + fb)
def detections(cfg, gtFolder, detFolder, savePath, show_process=True): # getGTBoxes函数 getDetBoxes函数 得到真实框 真实种类 和检测框 gt_boxes, classes, num_pos = getGTBoxes(cfg, gtFolder) det_boxes = getDetBoxes(cfg, detFolder) # 创建一个对象 evaluator = Evaluator() # 返回内容为 return evaluator.GetPascalVOCMetrics(cfg, classes, gt_boxes, num_pos, det_boxes)
def resultSimulate(self, matrix1, matrix2): ev1_1 = ev.Evaluator(1, matrix1) ev2_1 = ev.Evaluator(1, matrix2) ag1_1 = ag.AlphaBetaAgent(1, 4, ev1_1) # ind1 -> Blanco ag2_1 = ag.AlphaBetaAgent(2, 4, ev2_1) # ind2 -> Negro simulate1 = self.simulateGame(ag1_1, ag2_1) a1w, a2b, d1 = 0, 0, 0 if (simulate1 == 2): a2b += 1 elif (simulate1 == 1): a1w += 1 else: d1 += 1 ev1_2 = ev.Evaluator(1, matrix1) ev2_2 = ev.Evaluator(1, matrix2) ag1_2 = ag.AlphaBetaAgent(2, 4, ev1_2) # ind1 -> Negro ag2_2 = ag.AlphaBetaAgent(1, 4, ev2_2) # ind2 -> Blanco simulate2 = self.simulateGame(ag2_2, ag1_2) a2w, a1b, d2 = 0, 0, 0 if (simulate2 == 2): a1b += 1 elif (simulate2 == 1): a2w += 1 else: d2 += 1 a1 = a1w + a1b a2 = a2w + a2b d = d1 + d2 if a1 > a2: return matrix1, 1 elif a2 > a1: return matrix2, 2 else: random = randint(0, 1) if random == 0: return matrix1, -1 else: return matrix2, -2
def detections(cfg, gtFolder, detFolder, savePath, show_process=True): gt_boxes, classes, num_pos = getGTBoxes(cfg, gtFolder) det_boxes = getDetBoxes(cfg, detFolder) evaluator = Evaluator() # 传入配置,类别 return evaluator.GetPascalVOCMetrics(cfg, classes, gt_boxes, num_pos, det_boxes)
def __init__(self, maxlen, num_tags, word_index, embeddings, model_type, texts_to_eval_dir, dumpPath): self.num_tags = num_tags self.word_index = word_index self.texts_to_eval_dir = texts_to_eval_dir self.dumpPath = dumpPath self.model_maker = nm.NeuralModel(maxlen, num_tags, word_index, embeddings) num_measures = 1 + 3 * (num_tags - 2) self.evaluator = ev.Evaluator(num_tags, num_measures, self.model_maker.tags) self.postprocessing = pp.PostProcessing(num_tags, self.model_maker.tags)
def main(argv=None): t = Tokenizer.Tokenizer() e = Evaluator.Evaluator() if len(argv) == 1: try: argv = input("Enter an expression: ") except [IOError, ValueError]: result = "You've entered an invalid expression!" else: argv = sys.argv[1] rpn = t.shunting(argv) result = e.evaluate(rpn) print(result)
def run(): f = open('./config.yml') config = yaml.load(f) roi_shape = config['roi_shape'] dead_zone = config['dead_zone'] cube_resolution = config['cube_resolution'] laser_num = config['laser_num'] lidar_num = config['lidar_num'] beam_angle = config['beam_angle'] max_itrs = config['max_itrs'] numb_bees = config['numb_bees'] lower_bound = config['lower_bound'] * lidar_num upper_bound = config['upper_bound'] * lidar_num estimate_solve_time = config['estimate_solve_time'] save_result_to_json = config['save_result_to_json'] assert (len(beam_angle) == laser_num ), "Please check the number of beams' angles of pitch" eval.logConfig(config=config) VSR_solver = eval.Evaluator(roi_shape=roi_shape, dead_zone=dead_zone, cube_resolution=cube_resolution, laser_num=laser_num, lidar_num=lidar_num, pitch_angle=beam_angle) # creates model if estimate_solve_time: eval.estimateTime(config=config, VSR_solver=VSR_solver, Hive=Hive) now = time.time() model = Hive.BeeHive(lower=lower_bound, upper=upper_bound, fun=VSR_solver.solve, numb_bees=numb_bees, max_itrs=max_itrs, verbose=True) cost = model.run() total_time = time.time() - now print("Total time consume: ", total_time) print("Solution: ", model.solution) # prints out best solution print("Fitness Value ABC: {0}".format(model.best)) if save_result_to_json: eval.saveResults(config=config, model=model, total_time=total_time, cost=cost) # plots convergence Utilities.ConvergencePlot(cost)
def exeGaussianRandomBidModel(validationData, trainData=None, writeResult2CSV=False): # gaussian random Bidding Model randomBidModel = BidModels.GaussianRandomBidModel() bids = randomBidModel.getBidPrice(validationData.bidid) # bids = np.apply_along_axis(randomBidModel.getBidPrice, axis=1, arr=validationData.getTestData()) if writeResult2CSV: ipinyouWriter.ResultWriter().writeResult("resultGaussianRandomBidModel.csv", bids) # myEvaluator = Evaluator.Evaluator(25000*1000, bids, validationData.getTrainData()) # myEvaluator.computePerformanceMetrics() myEvaluator = Evaluator() myEvaluator.computePerformanceMetricsDF(6250 * 1000, bids, validationData) myEvaluator.printResult()
class ReglaCompuestaTrapecio: evaluator = Evaluator.Evaluator() def compuestaTrapecio(self, a, b, n): x = sympy.symbols('x') f = sympy.exp(x) - 2 * x #Funcion a integrar h = float(b - a) / n s = 0 xi = a + h for i in range(1, n): s += self.evaluator.evaluate(f, xi) xi += h fa = self.evaluator.evaluate(f, a) fb = self.evaluator.evaluate(f, b) print(float(h) / 2) * (fa + (2 * s) + fb)
def exeUniformRandomBidModel(validationData, trainData=None, writeResult2CSV=False): # uniform random Bidding Model randomBidModel = BidModels.UniformRandomBidModel(300) #upper bound for random bidding range # TODO: could train this too in a range. bids = randomBidModel.getBidPrice(validationData.bidid) # bids = np.apply_along_axis(randomBidModel.getBidPrice, axis=1, arr=validationData.getTestData()) if writeResult2CSV: ipinyouWriter.ResultWriter().writeResult("resultUniformRandomBidModel.csv", bids) # myEvaluator = Evaluator.Evaluator(25000*1000, bids, validationData.getTrainData()) # myEvaluator.computePerformanceMetrics() myEvaluator = Evaluator() myEvaluator.computePerformanceMetricsDF(6250 * 1000, bids, validationData) myEvaluator.printResult()
def runOnto(): print("Loading model, please wait. (This may take a while)") model = KeyedVectors.load_word2vec_format( dataDir + "\\GoogleNews-vectors-negative300.bin", binary=True) print("Model loaded") for i in range(0, 485): id = i print(id) filename = dataDir + "\\seminars_training\\training\\{}.txt".format(id) ev = Evaluator.Evaluator() file = ev.getFileToTag(filename) email = loadInFile(file, id) tree = OntologyTree.tree ont = OntologyTagger.OntologyTagger(email, model, tree, dataDir) tree = ont.findOntTreeMatch(ont.keyWordsInTopic()) ont.printTree(tree)
def __init__(self, anchors, size, metric_names: list, detect_thresh: float=0.3, nms_thresh: float=0.3 , images_per_batch: int=-1): self.ap = 'AP' self.anchors = anchors self.size = size self.detect_thresh = detect_thresh self.nms_thresh = nms_thresh self.images_per_batch = images_per_batch self.metric_names_original = metric_names self.metric_names = ["{}-{}".format(self.ap, i) for i in metric_names] self.evaluator = Evaluator() if (self.anchors.shape[-1]==4): self.boundingObjects = BoundingBoxes() else: self.boundingObjects = BoundingCircles()
def drawAllBoundingBoxes(self, gt, image_folder: Path, iou_thresh: float=0.25): font = cv2.FONT_HERSHEY_SIMPLEX fontScale = 0.5 fontThickness = 1 evaluator = Evaluator() boundingBoxes = self._extract_bounding_boxes(gt) images = {} for image_id in gt.images: image = np.zeros((376, 256,3), np.uint8) image[256:376, 0:256, :] = 255 image[0:256, 0:256, :] = cv2.imread(str(image_folder/image_id)) bbxesImage = BoundingBoxes() bbxes = boundingBoxes.getBoundingBoxesByImageName(image_id) for bb in bbxes: bbxesImage.addBoundingBox(bb) x1, y1, x2, y2 = bb.getAbsoluteBoundingBox(BBFormat.XYX2Y2) color = self.colors[bb.getClassId()] if bb.getBBType() == BBType.GroundTruth: cv2.line(image, (x1, y1), (x2, y2), color, 2) cv2.line(image, (x2, y1), (x1, y2), color, 2) else: cv2.rectangle(image, (x1, y1), (x2, y2), color, 2) metrics_per_class = evaluator.GetPascalVOCMetrics(bbxesImage, iou_thresh) for mc in metrics_per_class: cv2.putText(image, "Grade: {} mAP: {:01.2f}".format(mc['class'], mc['AP']), (10, 270 + int(20 * mc['class'])), font, fontScale, self.colors[mc['class']], fontThickness, cv2.LINE_AA) cv2.putText(image, "mAP: {:01.2f}".format( np.mean([np.nan_to_num(mc['AP']) for mc in metrics_per_class])), (10, 365), font, fontScale, (0,0,0), fontThickness, cv2.LINE_AA) images[image_id] = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) return images
def __init__(self): super(MyWindow, self).__init__() self.setupUi(self) self.tableWidget.setHorizontalHeaderLabels(['题目', '答案', '正确?']) self.timer = QTimer() self.label_3.setText('') self.label_4.setText('20s') self.g = Qg.QuestGenerator() self.ev = Evaluator.Evaluator() self.submitted = False self.correct = False self.remaining = 20 self.pushButton.clicked.connect(self.pushButton_clicked) self.pushButton_2.clicked.connect(self.pushButton_2_clicked) self.pushButton_3.clicked.connect(self.pushButton_3_clicked) self.timer.timeout.connect(self.timer_timeout)
def exeConstantBidModel(validationData, trainData=None, train=False, writeResult2CSV=False): # Constant Bidding Model constantBidModel = BidModels.ConstantBidModel(defaultbid=77) if train: constantBidModel.trainModel(trainData, searchRange=[1, 300], budget=int(6250*1000*8.88)) bids = constantBidModel.getBidPrice(validationData.bidid) # bids = np.apply_along_axis(constantBidModel.getBidPrice, axis=1, arr=validationData.getTestData()) if writeResult2CSV: ipinyouWriter.ResultWriter().writeResult("resultConstantBidModel.csv", bids) # myEvaluator = Evaluator.Evaluator(25000*1000, bids, validationData.getTrainData()) # myEvaluator.computePerformanceMetrics() myEvaluator = Evaluator() myEvaluator.computePerformanceMetricsDF(6250 * 1000, bids, validationData) myEvaluator.printResult()