loss, ap = train_encoder_decoder(**trainer_args)
                    print("Train loss: {0:.5f} AP: {1:.4f}".format(loss, ap))

                    val_args = {
                        "encoder": encoder,
                        "decoder": decoder,
                        "device": DEVICE,
                        "test_loader": val_loader,
                        "loss_function": loss_function,
                        "debug_mode": DEBUG_MODE,
                        "coordinate_trajectory_inputs": False,
                        "compute_ap": False,
                    }

                    loss, ap = test_encoder_decoder(**val_args)
                    print("Validation loss: {0:.5f} AP: {1:.4f}".format(
                        loss, ap))

                    if loss <= best_loss:
                        best_loss = loss
                        best_encoder = copy.deepcopy(encoder)
                        best_decoder = copy.deepcopy(decoder)
                        encoder_save_name = "encoder_fold_" + str(
                            fold) + ".weights"
                        decoder_save_name = "decoder_fold_" + str(
                            fold) + ".weights"
                        if not MODEL_SAVE_PATH is None:
                            torch.save(
                                best_encoder.state_dict(),
                                os.path.join(MODEL_SAVE_PATH,
Beispiel #2
0
    decoder = RecurrentDecoder(**decoder_args).to(DEVICE)
    encoder.load_state_dict(
        torch.load(
            os.path.join(MODEL_LOAD_PATH,
                         "encoder_fold_" + str(fold) + ".weights")))
    decoder.load_state_dict(
        torch.load(
            os.path.join(MODEL_LOAD_PATH,
                         "decoder_fold_" + str(fold) + ".weights")))

    loss_function = nn.BCELoss()

    # ########## EVALUATE ########## #

    test_args = {
        "encoder": encoder,
        "decoder": decoder,
        "device": DEVICE,
        "test_loader": test_loader,
        "loss_function": loss_function,
        "debug_mode": False,
        "fold_num": fold,
        "predictions_save_path": None,
        "variable_batch_size": True,
    }

    loss, ap = test_encoder_decoder(**test_args)
    print("Test loss: {0:.5f} AP: {1:.4f}".format(loss, ap))
    all_aps.append(ap)
print("MEAN AP:", np.round(np.mean(all_aps), 3) * 100)
                    loss, _ = train_encoder_decoder(**trainer_args)
                    print("Train loss: {0:.5f}".format(loss))

                    val_args = {
                        "encoder": encoder,
                        "decoder": decoder,
                        "device": DEVICE,
                        "test_loader": val_loader,
                        "loss_function": loss_function,
                        "debug_mode": DEBUG_MODE,
                        "coordinate_trajectory_inputs": False,
                        "compute_ap": False,
                    }

                    loss, _ = test_encoder_decoder(**val_args)
                    print("Validation loss: {0:.5f}".format(loss))

                    if loss < best_loss:
                        best_loss = loss
                        best_encoder = copy.deepcopy(encoder)
                        best_decoder = copy.deepcopy(decoder)

                        encoder_save_name = "encoder_fold_" + str(fold) + ".weights"
                        decoder_save_name = "decoder_fold_" + str(fold) + ".weights"

                        if not MODEL_SAVE_PATH is None:
                            if multi_view_tensors:
                                multi_view = "multi_view"
                            else:
                                multi_view = "single_view"