def process_image(image_path):
    """ Scales, crops, and normalizes a PIL image for a PyTorch model,
        returns an Numpy array
    """
    with Image.open(image_path) as image:
        transform = get_test_transforms()
        image = transform(image).numpy()

    return image
Beispiel #2
0
                   map_location=device))

    model2 = Darknet(os.path.join(
        BASE_DIR, "yolo_v3/config/yolov3-custom.cfg")).to(device)
    model2.load_state_dict(
        torch.load(os.path.join(models_path, "yolo_v3_4_20.pt"),
                   map_location=device))

    model3 = Darknet(os.path.join(
        BASE_DIR, "yolo_v3/config/yolov3-custom.cfg")).to(device)
    model3.load_state_dict(
        torch.load(os.path.join(models_path, "yolo_v3_4_25.pt"),
                   map_location=device))

    dataset = MyTestDataset(split='stage1_train',
                            transforms=get_test_transforms(rescale_size=(416,
                                                                         416)))

    test_loader = DataLoader(dataset,
                             batch_size=1,
                             num_workers=0,
                             shuffle=False)

    model.eval()
    model2.eval()
    model3.eval()
    for i, (image, targets) in enumerate(test_loader):
        image = image[0].to(device=device)
        name = targets["name"][0]
        start_time = time.time()
        with torch.no_grad():
            outputs = model(image)
Beispiel #3
0
        # image_copy.show()
        # image_copy.save(os.path.join(images_path, f"faster_rcnn/{attempt}/images/{name}.png"))
        print(f"{name}, time: {elapsed_time}")
        plt.imshow(image_copy)
        plt.show()
        break


if __name__ == "__main__":
    # torch.manual_seed(4)
    from models import model

    attempt = 7
    model_name = "faster_rcnn_7_30.pt"

    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    print(f"Running on {device}...")

    model.load_state_dict(
        torch.load(os.path.join(models_path, "faster_rcnn_7_30.pt"),
                   map_location=device))
    dataset = MyTestDataset(split='stage1_test',
                            transforms=get_test_transforms(rescale_size=(256,
                                                                         256)))
    test_loader = DataLoader(dataset,
                             batch_size=1,
                             num_workers=0,
                             shuffle=True)

    predict(model, test_loader)
Beispiel #4
0
    from yolo_v3.models import Darknet
    from unet.models import UNet

    faster_name = "faster_rcnn.pt"
    yolo_name = "yolo_v3.pt"
    unet_name = "unet.pt"

    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    print(f"Running on {device}")

    print(f"Loading {faster_name}")
    faster.load_state_dict(
        torch.load(os.path.join(models_path, faster_name),
                   map_location=device))
    faster.to(device=device)
    dataset = MyDemoDataset(transforms=get_test_transforms(rescale_size=(256,
                                                                         256)))
    faster_loader = DataLoader(dataset,
                               batch_size=1,
                               num_workers=0,
                               shuffle=False)

    print(f"Loading {yolo_name}")
    yolo = Darknet(os.path.join(BASE_DIR, "yolo_v3/config/yolov3-custom.cfg"))
    yolo.load_state_dict(
        torch.load(os.path.join(models_path, yolo_name), map_location=device))
    yolo.to(device=device)
    dataset = MyDemoDataset(transforms=get_test_transforms(rescale_size=(416,
                                                                         416)))
    yolo_loader = DataLoader(dataset,
                             batch_size=1,
                             num_workers=0,