def test_unsupervised_depth_problem_cpu(self):
     device = "cpu"
     sequence_8 = Downloader('08')
     if not os.path.exists("./dataset/poses"):
         print("Download dataset")
         sequence_8.download_sequence()
     lengths = (200, 30, 30)
     dataset = pykitti.odometry(sequence_8.main_dir,
                                sequence_8.sequence_id,
                                frames=range(0, 260, 1))
     dataset_manager = DatasetManagerMock(dataset,
                                          lenghts=lengths,
                                          num_workers=WORKERS_COUNT)
     model = UnDeepVO(max_depth=2., min_depth=1.0).to(device)
     optimizer_manger = OptimizerManager()
     criterion = UnsupervisedCriterion(
         dataset_manager.get_cameras_calibration(device), 0.1, 1, 0.85)
     handler = TrainingProcessHandler(mlflow_tags={"name": "test"})
     problem = UnsupervisedDepthProblem(model,
                                        criterion,
                                        optimizer_manger,
                                        dataset_manager,
                                        handler,
                                        batch_size=1,
                                        device=device)
     problem.train(1)
 def test_supervised_depth_problem(self):
     dataset = GroundTruthDataset(length=260)
     print (dataset._names)
     lengths = (200, 30, 30)
     dataset_manager = SupervisedDatasetManager(dataset, lengths=lengths, num_workers=WORKERS_COUNT)
     model = DepthNet(max_depth=2., min_depth=1.0).cuda()
     optimizer_manger = OptimizerManager()
     criterion = SupervisedCriterion(0.01)
     handler = TrainingProcessHandler(mlflow_tags={"name": "test"})
     problem = SupervisedDepthProblem(model, criterion, optimizer_manger, dataset_manager, handler,
                                      batch_size=1)
     problem.train(1)
Exemple #3
0
                               '08',
                               frames=range(*args.frames_range))
    dataset_manager = UnsupervisedDatasetManager(dataset, lenghts=lengths)

    model = UnDeepVO(args.max_depth).cuda()

    criterion = UnsupervisedCriterion(
        dataset_manager.get_cameras_calibration("cuda:0"),
        args.lambda_position, args.lambda_rotation, args.lambda_s,
        args.lambda_disparity)
    handler = TrainingProcessHandler(
        enable_mlflow=True,
        mlflow_tags={"name": args.mlflow_tags_name},
        mlflow_parameters={
            "image_step": args.frames_range[2],
            "max_depth": args.max_depth,
            "epoch": args.epoch,
            "lambda_position": args.lambda_position,
            "lambda_rotation": args.lambda_rotation,
            "lambda_s": args.lambda_s,
            "lambda_disparity": args.lambda_disparity
        })
    optimizer_manager = OptimizerManager(lr=args.lr)
    problem = UnsupervisedDepthProblem(model,
                                       criterion,
                                       optimizer_manager,
                                       dataset_manager,
                                       handler,
                                       batch_size=args.batch,
                                       name="undeepvo")

elif args.method == "supervised":
Exemple #4
0
    if args.model_path != "":
        model.load_state_dict(torch.load(args.model_path, map_location=args.device))
    criterion = UnsupervisedCriterion(dataset_manager.get_cameras_calibration(args.device),
                                      args.lambda_position,
                                      args.lambda_rotation,
                                      args.lambda_s,
                                      args.lambda_disparity,
                                      args.lambda_registration)
    handler = TrainingProcessHandler(enable_mlflow=True, mlflow_tags={"name": args.mlflow_tags_name},
                                     mlflow_parameters={"image_step": args.frames_range[2],
                                                        "max_depth": args.max_depth,
                                                        "epoch": args.epoch,
                                                        "lambda_position": args.lambda_position,
                                                        "lambda_rotation": args.lambda_rotation,
                                                        "lambda_s": args.lambda_s,
                                                        "lambda_disparity": args.lambda_disparity,
                                                        "lr": args.lr,
                                                        "batch_size": args.batch_size,
                                                        "betta2": args.betta2,
                                                        "betta1": args.betta1,
                                                        "min_depth": args.min_depth,
                                                        "lambda_registration": args.lambda_registration},
                                     enable_iteration_progress_bar=True)
    optimizer_manager = OptimizerManager(lr=args.lr, betas=(args.betta1, args.betta2))
    problem = UnsupervisedDepthProblem(model, criterion, optimizer_manager, dataset_manager, handler,
                                       batch_size=args.batch_size, name="undeepvo", device=args.device)

elif args.method == "supervised":
    dataset = GroundTruthDataset(length=lengths)
    dataset_manager = SupervisedDatasetManager(dataset, lengths=lengths)
Exemple #5
0
 def test_training_process_handler(self):
     handler = TrainingProcessHandler()
     handler.setup_handler("test", None)
     handler.start_callback(1, 1)
     handler.epoch_callback({})
     handler.finish_callback({})