Python evaluator.Evaluator类代码示例

def evaluate_classifier(clf_wrapper,
                        params,
                        train_images_codelabels, train_labels,
                        test_images_codelabels, test_labels):

    print "==\nevaluate_classifier (test size: {})\n{}".format(len(test_labels), clf_wrapper)

    print "training classifier {}".format(clf_wrapper.clf)
    start_time = time.time()
    clf_wrapper.fit(X=train_images_codelabels, labels=train_labels)
    et = (time.time() - start_time) * 1000.0
    print "finished training classifier - took {}ms".format(et)

    # evaluate
    print "proceeding to evaluate classifier on test set {}".format(len(test_labels))
    encoded_test_labels = clf_wrapper.label_encoder.transform(test_labels)

    evaluator = Evaluator(
        clf=clf_wrapper.clf,
        label_encoder=clf_wrapper.label_encoder,
        params=params,
        output_filepath="../results/evaluation_results_{}.json".format(clf_wrapper)
    )

    evaluator.results["classifier"] = "{}".format(clf_wrapper.clf)
    evaluator.results["classifier_training_time"] = "{}".format(et)

    evaluation_results = evaluator.evaluate(X=test_images_codelabels, y=encoded_test_labels)
    print evaluation_results

	def detect(self, img_path=None, output_file_prefix='', num_ft=100, offset=0, scaling_factor = 1.2, scaling_iters=3, nms=0.5, clf=None, templates=None, linear_scaling=False):
		
		#=====[ Load our classifier and templates ]=====
		clf = pickle.load(open(clf)) if clf else pickle.load(open('classifiers/top_ft_classifier_100_200', 'r'))
		templates = pickle.load(open(templates)) if templates else pickle.load(open('processed_data/top_templates_1000.p','r'))
	
		#=====[ Get top templates ]=====
		templates = templates[:num_ft]

		#=====[ Instantiate our feature generator ]=====
		fg = FeatureGenerator(templates)

		#=====[ Instantiate our detector ]=====
		if linear_scaling:
			self.detector = LinearScaleDetector(clf.clf, fg,scaling_factor=scaling_factor,scaling_iters=scaling_iters, nms=nms)
		else:
			self.detector = Detector(clf.clf, fg,scaling_factor=scaling_factor,scaling_iters=scaling_iters, nms=nms)

		#=====[ If a specific image path is given, then we do not evaluate, just detect the pedestrian and draw bounding boxes ]=====
		if img_path:
			_, bbs = self.detector.detect_pedestrians(img_path)
			self._draw_bbs(img_path, bbs)
		
		else:
			#=====[ Instantiate our evaluator and evaluate ]=====
			evaluator = Evaluator('INRIAPerson/Test', self.detector)
			FPPI, miss_rate = evaluator.evaluate(output_file_prefix,offset)

			print '\nFPPI: {}\nMiss rate: {}\n'.format(FPPI, miss_rate)

class NERValidator(object):
    def __init__(self, recbysns, classifiers):
        self.recbysns = recbysns
        self.db = self.recbysns.db
        self.classifiers = classifiers
        self.evaluator = Evaluator()
        self.confusion_matrixes = {str(classifier):
                                   [] for classifier in self.classifiers}

    def validate(self):
        entities = [NEREntity(self.recbysns, entity)
                    for entity in self.db.select_table('recbysns_entity', '1')]
        for classifier in self.classifiers:
            self.test(classifier, entities)
        self.evaluator.evaluate(self.confusion_matrixes)

    def test(self, classifier, entities):
        confusion_matrix = {
                NER_BOOK:   {NER_BOOK: float(0), NER_MOVIE: float(0),
                             NER_VIDEO: float(0), NER_OTHERS: float(0)},
                NER_MOVIE:  {NER_BOOK: float(0), NER_MOVIE: float(0),
                             NER_VIDEO: float(0), NER_OTHERS: float(0)},
                NER_VIDEO:  {NER_BOOK: float(0), NER_MOVIE: float(0),
                             NER_VIDEO: float(0), NER_OTHERS: float(0)},
                NER_OTHERS: {NER_BOOK: float(0), NER_MOVIE: float(0),
                             NER_VIDEO: float(0), NER_OTHERS: float(0)},
        }
        for entity in entities:
            # predicted ner class
            p_ner_class = classifier.predict(entity)
            ner_class = entity.ner_class()
            confusion_matrix[ner_class][p_ner_class] += 1
        print confusion_matrix
        self.confusion_matrixes[str(classifier)].append(confusion_matrix)

def __main__(argv):
    #%%
    logger = logging.getLogger(__name__)
    logger.info("VECTOR MODEL INFORMATION RETRIEVAL SYSTEM START")    
    
    gli = InvertedIndexGenerator(GLI_CONFIG_FILE)
    gli.run()
    gli.write_output()
    
    index = Indexer(INDEX_CONFIG_FILE, TfidfVectorizer)
    index.run()
    index.write_output()
    
    pc = QueryProcessor(PC_CONFIG_FILE)
    pc.run()
    pc.write_output()
    
    buscador = SearchEngine(BUSCA_CONFIG_FILE, TfidfVectorizer)
    buscador.run()
    buscador.write_output()
    #%%
    avaliador = Evaluator(AVAL_CONFIG_FILE)
    avaliador.run()
    avaliador.write_output()
    
    logger.info("VECTOR MODEL INFORMATION RETRIEVAL SYSTEM DONE")     

 def p_interpreter_other(self, p):
     '''interpreter : comparision
                    | select
                    | array_selection
                    | func_call_stmt
                    | expression'''
     print Evaluator.visit(p[1])

class SAValidator(object):
    def __init__(self, recbysns, classifiers):
        self.recbysns = recbysns
        self.db = self.recbysns.db
        self.classifiers = classifiers
        self.evaluator = Evaluator()
        self.confusion_matrixes = {str(classifier): []
                                   for classifier in self.classifiers}

    def validate(self):
        entities = [SAEntity(self.recbysns, entity)
                    for entity in self.db.select_table('recbysns_entity',
                    "type in (%d,%d,%d)" % (NER_BOOK, NER_MOVIE, NER_VIDEO))]
        for classifier in self.classifiers:
            self.test(classifier, entities)
        self.evaluator.evaluate(self.confusion_matrixes)

    def test(self, classifier, entities):
        confusion_matrix = {
                SA_POSITIVE: {SA_POSITIVE: float(0), SA_NETURAL: float(0),
                              SA_NEGATIVE: float(0)},
                SA_NETURAL:  {SA_POSITIVE: float(0), SA_NETURAL: float(0),
                              SA_NEGATIVE: float(0)},
                SA_NEGATIVE: {SA_POSITIVE: float(0), SA_NETURAL: float(0),
                              SA_NEGATIVE: float(0)},
        }
        for entity in entities:
            # predicted sa_class
            p_sa_class = classifier.predict(entity)
            # actual sa_class
            sa_class = entity.sa_class()
            confusion_matrix[sa_class][p_sa_class] += 1
        print confusion_matrix
        self.confusion_matrixes[str(classifier)].append(confusion_matrix)

 def run(self):
     while 1:
         try:
             s = raw_input('calc> ')
         except EOFError:
             break
         if not s: continue
         Evaluator.visit(yacc.parse(s))

def window_overlap_test(window_overlap=2.):
    """  """

    train_labels, train_images, test_labels, test_images = get_training_and_test_data()

    # split to make experimentation quicker
    train_labels, train_images = get_subset_of_training_data(train_labels, train_images, split=0.5)

    training_size = len(train_labels)

    desc = "testing influence of window_overlap, set to {}. NB training size = {}".format(
        window_overlap,
        training_size
    )

    print desc

    selected_labels = list(set(train_labels))

    params = build_params(num_classes=len(selected_labels),
                          training_size=len(train_images),
                          test_size=len(test_images),
                          window_overlap=window_overlap,
                          fn_prefix="winoverlap-{}".format(window_overlap))

    trainer = SketchRecognitionTrainer(
        file_path=SketchRecognitionTrainer.get_cookbook_filename_for_params(params=params),
        run_parallel_processors=True,
        params=params
    )

    classifier = trainer.train_and_build_classifier(train_labels, train_images)
    encoded_test_labels = classifier.le.transform(test_labels)

    test_images_codelabels = trainer.code_labels_for_image_descriptors(
        trainer.extract_image_descriptors(test_images)
    )

    evaluator = Evaluator(
        clf=classifier.clf,
        label_encoder=classifier.le,
        params=params,
        output_filepath=SketchRecognitionTrainer.get_evaluation_filename_for_params(params=params)
    )

    # add timings to output
    evaluator.results["timings"] = {}
    for key, value in trainer.timings.iteritems():
        evaluator.results["timings"][key] = value

    # add comment
    evaluator.results["desc"] = desc

    evaluation_results = evaluator.evaluate(X=test_images_codelabels, y=encoded_test_labels)
    print evaluation_results

class Test(unittest.TestCase):


    def setUp(self):
        gold_directory = os.path.join(DATA_DIRECTORY, 'segment_data_test')
        result_directory = os.path.join(DATA_DIRECTORY, 'data_test_result')
        self.evaluator = Evaluator(gold_directory, result_directory)


    def test_calculate_precision(self):
        self.evaluator.calculate_precision()

def main():
	if len(sys.argv) != 6:
		assert False, "INSUFFICIENT ARGUMENTS!"

	filenames = [line.strip() for line in open(sys.argv[4])]
	ann_filepaths = [sys.argv[5] + '/' + filename[:len(filename)-4]+".ann" for filename in filenames]
	# print(ann_filepaths)
	
	data_param = {"dataset_name": sys.argv[1], "ann_filepaths": ann_filepaths,"n_label": int(sys.argv[2]), "gt_img_dir": sys.argv[3], "test_img_list_filepath": sys.argv[4], "result_dir": sys.argv[5], "mapping_label": color_class_map, "dir_output": sys.argv[5]}

	eval = Evaluator(data_param)
	eval.evaluate_all()

def main():
    mode = argv[1]
    e = Evaluator()
    if mode == 'wikt':
        e.read_all_wiktionary()
        e.compare_with_triangles_stdin()
    elif mode == 'feat':
        e.write_labels(argv[2])
        e.featurize_and_uniq_triangles_stdin()

 def _process(self):
     self.msg = self._receive(True)
     if self.msg:
         request = json.loads(self.msg.content)
         if request['request_type'] == 'games':
             self.games = request['data']
             self.show_dialog()
         if request['request_type'] == 'game_evaluation':
             PrintFormatter.results(request['data'])
             Evaluator.make_bet(self.mood, request['data'])
             print "\n********Results********\n"
             Evaluator.find_result(request['data'])
             self.show_dialog()

def main():
    """Requests infix expressions, translates them to postfix,
    and evaluates them, until the user enters nothing."""
    while True:
        sourceStr = input("Enter an infix expression: ")
        if sourceStr == "": break
        try:
            scanner = Scanner(sourceStr)
            translator = Translator(scanner)
            postfix = translator.translate()
            evaluator = Evaluator(postfix)
            print("Value:", evaluator.evaluate())
        except Exception as e:
            print("Error:", e, translator.translationStatus())

    def test_end_to_end(self):
        with open("unit_tests/fixtures/tests_games.json") as file:
            data = json.loads(file.read())

        # Update player's source placeholder with actual code
        with open("unit_tests/fixtures/Snakes/Snakes.cpp") as source:
            data["source"] = source.read()

        # Update opponent's source placeholder with actual code
        with open("unit_tests/fixtures/Snakes/Opponent.cpp") as source:
            data["matches"][0]["source"] = source.read()

        evaluator = Evaluator(data)
        evaluator.evaluate()

    def solve(self, instance, startpoint=None):
        if startpoint is None:
            startpoint = Random().solve(instance)

        e = Evaluator(instance)
        current = (startpoint, e.evaluate(startpoint))

        while True:
            next_step = self.select_step(e, current)
            if not next_step:
                break
            else:
                current = next_step

        return current[0]