示例#1
0
def predict(args):
	# get only the grayscale image that is stored in the blue channel

	img = Image.open(args.image_path)
	if img.mode == 'RGB':
		print("Only taking blue channel from RGB image")
		img = img.split()[2]
	elif img.mode == 'L':
		print("Provided image is already grayscale")

	
	transform = transforms.Compose([transforms.Resize(256), transforms.ToTensor(),
	                                transforms.Normalize(mean=[0.485], std=[0.229])])
	
	# img = img.split()[2]
	img_t = transform(img)
	batch_t = torch.unsqueeze(img_t, 0)
	
	model = Model()
	
	checkpoint = torch.load(args.model_weights)
	model.load_state_dict(checkpoint['state_dict'])
	
	model.eval()
	out = model(batch_t)
	_, preds = torch.max(out, 1)
	
	print('Result: ', args.all_labels[preds.item()])
 def get_gesture_model(weights_path):
     model = Model(42, 32, 5)
     if torch.cuda.is_available():
         model.load_state_dict(torch.load(weights_path))
         model = model.cuda()
     else:
         model.load_state_dict(
             torch.load(weights_path,
                        map_location=lambda storage, loc: storage))
     model.eval()
     return model
示例#3
0
def main():
	print("Abhishek Kumar")
	print("15648")
	print("CSA")

	parser = argparse.ArgumentParser()
	parser.add_argument("--test-data", default='test_input.txt', type=str, help="Name of the test file")
	args = parser.parse_args()
	
	model_path='model/model.bin'
	model = Model(h=4)
	device = "cpu"
	model.to(device)
	eval_dataset,w,data = read_test_data(args.test_data)
	model.load_state_dict(torch.load(model_path))
	evaluate(model, eval_dataset,device,w,data)
示例#4
0
def main():
    print(check_output(["nodejs", "--version"]))

    torch.backends.cudnn.benchmark = True

    # Increasing `repeat` will generate more cached files
    transform = CacheNPY(prefix="b64_",
                         repeat=1,
                         transform=torchvision.transforms.Compose([
                             ToMesh(random_rotations=True,
                                    random_translation=0.1),
                             ProjectOnSphere(bandwidth=64)
                         ]))
    transform = KeepName(transform)

    resdir = "test_perturbed"
    dataset, perturbed = resdir.split("_")
    perturbed = (perturbed == "perturbed")

    test_set = Shrec17("data",
                       dataset,
                       perturbed=perturbed,
                       download=True,
                       transform=transform)

    loader = torch.utils.data.DataLoader(test_set,
                                         batch_size=16,
                                         shuffle=False,
                                         num_workers=4,
                                         pin_memory=True,
                                         drop_last=False)

    model = Model(55)
    model.cuda()

    model.load_state_dict(torch.load("state.pkl"))

    if os.path.isdir(resdir):
        shutil.rmtree(resdir)
    os.mkdir(resdir)

    predictions = []
    ids = []

    for batch_idx, data in enumerate(loader):
        model.eval()

        if dataset != "test":
            data = data[0]

        file_names, data = data

        data = data.cuda()
        data = torch.autograd.Variable(data, volatile=True)

        predictions.append(model(data).data.cpu().numpy())
        ids.extend([x.split("/")[-1].split(".")[0] for x in file_names])

        print("[{}/{}]      ".format(batch_idx, len(loader)))

    predictions = np.concatenate(predictions)

    ex = np.exp(predictions - np.max(predictions, axis=1, keepdims=True))
    softmax = ex / np.sum(ex, axis=1, keepdims=True)

    predictions_class = np.argmax(predictions, axis=1)

    for i in range(len(ids)):
        print("{}/{}    ".format(i, len(ids)), end="\r")
        idfile = os.path.join(resdir, ids[i])

        retrieved = [(softmax[j, predictions_class[j]], ids[j])
                     for j in range(len(ids))
                     if predictions_class[j] == predictions_class[i]]
        retrieved = sorted(retrieved, reverse=True)
        threshold = 0
        retrieved = [i for prob, i in retrieved if prob > threshold]

        with open(idfile, "w") as f:
            f.write("\n".join(retrieved))

    url = "https://shapenet.cs.stanford.edu/shrec17/code/evaluator.zip"
    file_path = "evaluator.zip"

    r = requests.get(url, stream=True)
    with open(file_path, 'wb') as f:
        for chunk in r.iter_content(chunk_size=16 * 1024**2):
            if chunk:  # filter out keep-alive new chunks
                f.write(chunk)
                f.flush()

    zip_ref = zipfile.ZipFile(file_path, 'r')
    zip_ref.extractall(".")
    zip_ref.close()

    print(check_output(["nodejs", "evaluate.js", "../"], cwd="evaluator"))
示例#5
0
文件: main.py 项目: sriyash421/pDNN
        model = Model(momentum=params["MOMENTUM"],
                      nesterov=params["NESTEROV"],
                      learn_rate=params["LEARN_RATE"],
                      learn_rate_decay=params["LR_DECAY"],
                      sig_class_weight=params["SIG_WT"],
                      bkg_class_weight=params["BKG_WT"],
                      threshold=params["THRESHOLD"],
                      optimizer=params["OPT"],
                      loss_fn=loss_fn,
                      output_fn=output_fn,
                      layers=params["LAYERS"],
                      nodes=params["NODES"],
                      dropout=params["DROPOUT"],
                      activation=params["ACTIVATION"],
                      input_size=len(params["FEATURES"]),
                      id_dict=type2id,
                      save_tb_logs=params["SAVE_TB_LOGS"],
                      save_metrics=params["METRICS"],
                      save_wt_metrics=params["WT_METRICS"])

        dataset.prepare_data()
        dataset.setup("test")

        test_dataset = dataset.test_dataloader()
        training_metrics = model.metrics
        model.load_state_dict(torch.load(params["LOAD_DIR"])['state_dict'],
                              strict=False)
        final_logs(model, test_dataset, params["THRESHOLD"], output_fn,
                   type2id, gpus, None, params["LOG_DIR"])
#!/usr/bin/python
import json
import os
import torch
from torch.autograd import Variable
from train import Model, encode

current_dir = os.path.dirname(__file__)
model_file = os.path.join(current_dir, 'SplitModel.pt')
data_file = os.path.join(current_dir, 'data.json')
output_file = os.path.join(current_dir, 'prediction.json')

model = Model()
model.load_state_dict(torch.load(model_file))

with open(data_file) as f:
    examples = json.load(f)

data = Variable(torch.stack([encode(p['points']) for p in examples]))
logits = model(data)
prediction = []
for example, probs in zip(examples, logits):
    prediction.append([
        i for i, prob in enumerate(list(probs))
        if float(prob) >= 0.5 and i < len(example['points'])
    ])

with open(output_file, 'w') as f:
    json.dump(prediction, f)