Esempio n. 1
0
def check_classifier(with_external_picture: bool):
    bc = BinClassifier()
    bc.load(classifier_name="classifier_without_examples")

    if not with_external_picture:
        (x_train, y_train), (x_test, y_test) = get_dataset()
        test(bc, x_test, y_test)
    else:
        test_all_local(bc, full_res=False)
Esempio n. 2
0
def classify_outputs(input, outputs):
    '''This classifies program evaluation outputs and returns a dictionary
    mapping each program to the probability its output is correct.

    Arguments:
        - input (str): The input string used for each program evaluation
        - outputs (list): a list of evaluated outputs for each program

    Returns:
        - (list) an ordered list of outputs by highest probability that the output was correct.
    '''

    clist=[]
    clist=classifier.test(input,outputs)
    o=outputs[clist.index(max(clist))]
    d=dict(zip(outputs,clist))
    #print(d)
    a1 = sorted(d.items(),key = lambda x:x[1],reverse = True)
    #print(a1)
    sample_key_list = []

    for item in a1:
        sample_key_list.append(item[0])
    #print(sample_key_list)
    return sample_key_list
Esempio n. 3
0
def test():
    classfier_name = request.forms.get('classfier_name')
    classfier_dump = request.forms.get('classfier')
    features_train, labels_train = wtf.getArrays()
    clf = pickle.loads(classfier_dump)
    preditions, accuracy, recall, precision = classifier.test(clf = clf, features = features_train, labels = labels_train)



    return data1+data2
Esempio n. 4
0
def test():
    callback = request.GET.get('callback')
    classifier_name = request.GET.get('classifier_name')
    classifier_dump = request.GET.get('classifier')
    collection_id = request.GET.get('collection_id')
    print("Params :")
    print(classifier_name)
    features_train, labels_train = wtf.getArrays(collection_id)
    clf = pickle.loads(classifier_dump)
    preditions, accuracy, recall, precision = classifier.test(clf = clf, features = features_train, labels = labels_train)
    print("Test :")
    print("accuracy" + accuracy)
    print("precision" + precision)
    print("recall" + recall)
    data1 = test_data_to_send(classifier_id, 0, " ", precision, accuracy, recall)
    post.send("http://localhost:8080/dataprocessing/rest-api","/result_test_classifier","",data1)

    return '{0}({1})'.format(callback, {'a':1, 'b':2})
Esempio n. 5
0
def test():
    callback = request.GET.get('callback')
    classifier_name = request.GET.get('classifier_name')
    classifier_dump = request.GET.get('classifier')
    collection_id = request.GET.get('collection_id')
    print("Params :")
    print(classifier_name)
    features_train, labels_train = wtf.getArrays(collection_id)
    clf = pickle.loads(classifier_dump)
    preditions, accuracy, recall, precision = classifier.test(
        clf=clf, features=features_train, labels=labels_train)
    print("Test :")
    print("accuracy" + accuracy)
    print("precision" + precision)
    print("recall" + recall)
    data1 = test_data_to_send(classifier_id, 0, " ", precision, accuracy,
                              recall)
    post.send("http://localhost:8080/dataprocessing/rest-api",
              "/result_test_classifier", "", data1)

    return '{0}({1})'.format(callback, {'a': 1, 'b': 2})
Esempio n. 6
0
def _test_custom_classifier(classifier):
    util.debug("Testing classifier with test data")
    stats = {}
    for cls in CLASSES:
        stats[cls] = { 'total': 0, 'correct': 0, 'incorrect': 0 }

    # We'll throw away the class it yields
    for img_pixels, cls in util._test_data(CLASSES):
        classification, score = classifier.test(img_pixels)
        # util.debug("Actual: {}, Classification: {}, Score: {}".format(cls, classification, score))

        stats[cls]['total'] += 1
        if classification == cls:
            stats[cls]['correct'] += 1
        else:
            stats[cls]['incorrect'] += 1

    for cls in stats:
        stats[cls]['accuracy'] = stats[cls]['correct'] / stats[cls]['total']

    return stats
Esempio n. 7
0
import torch
import os
import torchvision

from model import TinyModel
from torchvision import transforms
from torch.utils.data import DataLoader
from torchvision.datasets import ImageFolder
from classifier import test

if __name__ == "__main__":
    model = TinyModel()
    model.load_state_dict(torch.load("checkpoints/epoch_90_0.955.pt"))

    test_trans = transforms.Compose([
        transforms.ToTensor(),
        transforms.Lambda(lambda x: x.repeat(1, 1, 1)),
        transforms.Normalize([0.4100, 0.4100, 0.4100],
                             [0.1165, 0.1165, 0.1165])
    ])
    test_datasets = ImageFolder(os.path.join("ROI_data", "test"),
                                transform=test_trans)

    print(test_datasets.classes)
    test_dataloader = DataLoader(test_datasets, batch_size=32, shuffle=False)
    criterion = torch.nn.CrossEntropyLoss()
    acc = test(model, test_dataloader, criterion)
Esempio n. 8
0
    logger.critical("Uncaught exception",
                    exc_info=(exc_type, exc_value, exc_traceback))


sys.excepthook = handle_exception

if device == 'cpu':
    os.environ['CUDA_VISIBLE_DEVICES'] = ''
    logger.debug("Using CPU only")
elif device == 'gpu0':
    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
    logger.debug("Using GPU 0")
elif device == 'gpu1':
    os.environ['CUDA_VISIBLE_DEVICES'] = '1'
    logger.debug("Using GPU 1")
elif device == 'gpu':
    os.environ['CUDA_VISIBLE_DEVICES'] = '0,1'
    logger.debug("Using GPU 0 and 1")

test(logger=logger,
     dataset=dataset,
     t=time_length,
     job_uuid=job_uuid,
     epoch=epoch,
     val_loss=val_loss,
     visualize_score=True,
     visualize_frame=False)

logger.info("Job {} ({}) has finished testing.".format(job_uuid, dataset))
Esempio n. 9
0
def main(params, input_dir="data", output_dir="out", cuda_enable=False):

    for data_file in ["zoomeddata_32_64_64.hdf5"]:

        d_train, d_dev, d_test = load_data(os.path.join(input_dir, data_file), img_size=params["img_size"])

        # build the vocabulary for images
        vocab = {
            "subfamily": [],
            "tribe": [],
            "genus": []
        }
        for d in d_train:
            vocab["subfamily"].append(d[1][0])
            vocab["tribe"].append(d[1][1])
            vocab["genus"].append(d[1][2])
        for k in vocab:
            vocab[k] = list(set(vocab[k]))

        mean_image = np.mean([d[0] for d in d_train])
        std_image = np.std([d[0] for d in d_train])

        def normalize_fn(X):
            return ((X - mean_image) / 255.)

        def process_data(data, tree_label=False):
            rand_indices = np.random.permutation(len(data))
            if not tree_label:
                data_out = [(normalize_fn(data[i][0]), vocab["genus"].index(data[i][1][2])) 
                            for i in rand_indices]
            else:
                data_out = [(normalize_fn(data[i][0]),
                             np.array([vocab["subfamily"].index(data[i][1][0]), 
                                       vocab["tribe"].index(data[i][1][1]), 
                                       vocab["genus"].index(data[i][1][2])])) 
                            for i in rand_indices]
            return data_out

        if params["add_synthetic_data"]:
            synthesized = gen_synthetic(d_train)
            print("{} synthetic examples added.".format(len(synthesized)))
        else:
            synthesized = []

        tree_label = params["tree_prediction"]

        train_data = batch_data(process_data(d_train + synthesized, tree_label), batch_size=params["batch_size"])
        dev_data = batch_data(process_data(d_dev, tree_label), batch_size=params["batch_size"])
        test_data = batch_data(process_data(d_test, tree_label), batch_size=params["batch_size"])

        #net = LinearModel(params, len(vocab["genus"]))
        #net = SimpleNet(params, len(vocab["genus"]))
    
        for model_class in [LinearModel, SimpleNet, SimpleConvNet, ConvNet]:
            print(">>>>>>>>>> {} <<<<<<<<<<".format(model_class))

            if tree_label:
                num_classes = len(vocab["subfamily"]) + len(vocab["tribe"]) + len(vocab["genus"])
            else:
                num_classes = len(vocab["genus"])

            net = model_class(params, num_classes)
            
            train_acc, dev_acc = classifier.train(net, train_data, dev_data, vocab, params, cuda_enable)

            for test_index in [0, 1, 2]:
                test_acc = classifier.test(net, test_data, vocab, cuda_enable, tree_label, test_index)
                print("[Test accuracy for label {} is {}]".format(test_index, test_acc))

            ## show images
            #if examples_to_demo > 0:
            #    show_data = [d_dev[i] for i in np.random.randint(len(dev_data), size=examples_to_demo)]
            #    show_data = batch_data(process_data(show_data), batch_size=1) 
            #    classifier.test(net, show_data, cuda_enable, show_example=True)

            with open(os.path.join(output_dir, "result_{}.log".format(model_class.__name__)), "w") as f:
                f.write("train_acc, dev_acc\n")
                for i in range(len(train_acc)):
                    f.write("{:.3f}".format(train_acc[i]) + ", " + "{:.3f}".format(dev_acc[i]) + "\n")
Esempio n. 10
0
                                            config["max_image_size"],
                                            config["canvas"],
                                            test_set["random"], model)

        data_test = test_set["genuines"] + test_set["skilled"] + test_set[
            "random"]
        test_classes = []
        for i in test_set["genuines"]:
            test_classes.append(1)
        for i in test_set["skilled"]:
            test_classes.append(0)
        for i in test_set["random"]:
            test_classes.append(0)
        test_sets.append(data_test)
    partial_results = classifier.test(clf_mlp, test_sets, test_classes,
                                      test_config["genuine"],
                                      test_config["skilled"],
                                      test_config["random"])
    results["mlp"][0] += (partial_results[0])
    results["mlp"][1] += (partial_results[1])
    results["mlp"][2] += (partial_results[2])
    results["mlp"][3] += (partial_results[3])
    results["mlp"][4] += (partial_results[4])
    results["mlp"][5] += (partial_results[5])
    results["mlp"][6] += (partial_results[6])
    partial_results = classifier.test(clf_svm_linear, test_sets, test_classes,
                                      test_config["genuine"],
                                      test_config["skilled"],
                                      test_config["random"])
    results["svm_linear"][0] += (partial_results[0])
    results["svm_linear"][1] += (partial_results[1])
    results["svm_linear"][2] += (partial_results[2])
Esempio n. 11
0
Meant to be deployed with Apache Spark
"""
import csv, classifier, db, spark, time, write
import numpy as np

TRAIN_FILENAME = './data/smtrain.csv'
TEST_FILENAME = './data/smtest.csv'
SKLEARN_PATH = './data/models/sklearn'
SPARK_PATH = './data/models/spark'

if __name__ == '__main__':
    # read the training data
    xtrain, ytrain = classifier.readdata(TRAIN_FILENAME)
    xtest, ytest = classifier.readdata(TEST_FILENAME)
    countvect, transformer, model = classifier.train(xtrain, ytrain)
    acc, model = classifier.test(model, xtest, ytest, countvect, transformer)

    print('Sklearn acc: {}'.format(acc))

    print('Saving sklearn')
    classifier.save(SKLEARN_PATH, model, countvect, transformer)
    countvect, transformer, model = classifier.load(SKLEARN_PATH)
    print(classifier.predict(model, ['i like something'], countvect, transformer))

    # start looping over tweets
    # for tweet in db.gettweets():
    #     text = [tweet['text']]
    #     prediction = clf.predict(classifier.transform(text))
    #     print(text, ' ^^ ', prediction)
    #     time.sleep(0.5) 
arr = [(86, 0.001149, '6ab962e0-b3bb-47d1-a513-4d68bdd2e08c', 0)]
arr = [(64, 0.000858, 'ae14934b-6961-45b1-b712-00381beef7dc', 0)]
arr = [(11, 0.003981, 'c0d6c0db-1a41-4089-9f05-ce9aaf7f9ccd', 0)]
arr = [(100, 0.003988, '968b2b8d-ba69-49fb-a27a-6d20787c4629', 0)]
arr = [(100, 0.003504, 'd1e9c23c-e754-4027-be93-111069ea3b81', 0)]
arr = [(298, 0.003159, 'f5846318-6990-4622-b584-ececf33a54d7', 0)]

# UCSD Ped2
# arr = [(749, 0.000554, '537f1112-8ec0-44eb-a380-c3a6e5a3c698', 0)]
# CUHK
# arr = [(227, 0.000455, 'c51f37de-9c2c-4941-b881-5029044a4564', 0)]

for item in arr:
    print("TESTING UUID", item[2])
    print("###Testing epoch", item[0])
    test(logger=logger,
         dataset=dataset,
         t=item[3],
         job_uuid=item[2],
         epoch=item[0],
         val_loss=item[1],
         visualize_score=True,
         visualize_frame=True)

# n_videos = {'avenue': 21, 'enter': 6, 'exit': 4, 'UCSD_ped1': 36, 'UCSD_ped2': 12}
# save_path = os.path.join(job_folder, 'result')
# auc_overall, eer_overall = calc_auc_overall(logger, dataset, n_videos[dataset], save_path)
# auc_overall, eer_overall = calc_auc_pixel(logger, dataset, n_videos[dataset], save_path)

logger.info("Job {} ({}) has finished testing.".format(job_uuid, dataset))