Exemple #1
0
 def predict():
     nonlocal output_dict
     model.eval()
     with torch.no_grad():
         input_dict_cuda, label_dict_cuda = rhodin_utils_datasets.nestedDictToDevice((input_dict, label_dict), device=device)
         output_dict_cuda = model(input_dict_cuda)
         output_dict = rhodin_utils_datasets.nestedDictToDevice(output_dict_cuda, device='cpu')
def main():
    swap_bg_treadmill()
    return
    import latent_space_nn as lsn
    dataset_path = '../data/pain_no_pain_x2h_intervals_for_extraction_128_128_2fps/'
    config_path = 'configs/config_train_rotation_newCal.py'
    job_identifier = 'withRotNewCal'
    out_dir = '../scratch/rot'
    nth_frame = 10

    # dataset_path = '../data/pain_no_pain_x2h_intervals_for_extraction_672_380_0.2fps_crop/'
    # config_path = 'configs/config_train_rotation_crop_newCal.py'
    # job_identifier = 'withRotCropNewCal'
    # out_dir = '../scratch/rotcrop'
    # nth_frame = 1

    util.mkdir(out_dir)

    model_num = 50
    batch_size_test = 64
    output_to_get = ['img_crop']
    input_to_get = ['img_crop']
    train_subjects = 'brava/herrera/inkasso/julia/kastanjett/naughty_but_nice/sir_holger'.split(
        '/')
    test_subject = 'aslan'
    all_subjects = train_subjects + [test_subject]

    config_dict = lsn.set_up_config_dict(config_path, train_subjects,
                                         [test_subject], job_identifier,
                                         batch_size_test, dataset_path,
                                         input_to_get, output_to_get)
    model_path = lsn.get_model_path(config_dict, str(model_num))

    config_dict['pretrained_network_path'] = model_path
    config_dict['every_nth_frame'] = nth_frame

    ignite = lsn.IgniteTestNVS()
    model, data_loader, config_dict = ignite.run(config_path, config_dict)
    data_iterator = iter(data_loader)

    for input_dict, label_dict in data_iterator:
        # input_dict['bg_crop'] = torch.max(input_dict['img_crop'])*torch.ones(input_dict['img_crop'].size())
        input_dict_cuda, label_dict_cuda = rhodin_utils_datasets.nestedDictToDevice(
            (input_dict, label_dict), device=device)
        output_dict_cuda = model(input_dict_cuda)
        utils_plot_batch.plot_iol(input_dict_cuda, label_dict_cuda,
                                  output_dict_cuda, config_dict, 'train',
                                  os.path.join(out_dir, 'lps_true.jpg'))

        input_dict['bg_crop'] = 0 * torch.ones(input_dict['img_crop'].size())
        input_dict_cuda, label_dict_cuda = rhodin_utils_datasets.nestedDictToDevice(
            (input_dict, label_dict), device=device)
        output_dict_cuda = model(input_dict_cuda)
        utils_plot_batch.plot_iol(input_dict_cuda, label_dict_cuda,
                                  output_dict_cuda, config_dict, 'train',
                                  os.path.join(out_dir, 'lps_white.jpg'))
        break
 def predict(self, input_dict, label_dict):
     self.model.eval()
     with torch.no_grad():
         input_dict_cuda, label_dict_cuda = rhodin_utils_datasets.nestedDictToDevice(
             (input_dict, label_dict), device=device)
         output_dict_cuda = self.model(input_dict_cuda)
         output_dict = rhodin_utils_datasets.nestedDictToDevice(
             output_dict_cuda, device='cpu')
     return output_dict
Exemple #4
0
    def _inference(engine, batch):
        # now compute error
        model.eval()
        with torch.no_grad():
            x, y = utils_data.nestedDictToDevice(
                batch, device=device)  # make it work for dict input too
            if forward_fn is None:
                y_pred = model(x)
            else:
                y_pred = forward_fn(x)

        return y_pred, y
def swap_bg_treadmill():
    config_path = 'configs/config_pose_debug.py'
    train_subjects = ['HOR', 'LAC', 'LAR', 'LAZ', 'LEA', 'LOR', 'PRA']
    test_subjects = ['ART']

    job_identifier = 'testing_bg_swap'
    batch_size_test = 64
    dataset_path = '../data'
    config_path = 'configs/config_pose_debug.py'
    job_identifier = 'withRotCropNewCal'

    output_to_get = ['img_crop']
    input_to_get = ['img_crop']

    train_subjects_model = 'brava/herrera/inkasso/julia/kastanjett/naughty_but_nice/sir_holger'.split(
        '/')
    test_subjects_model = ['aslan']
    epoch_encdec = str(50)
    config_file_model = 'configs/config_train_rotation_newCal.py'
    job_identifier_encdec = 'withRotNewCal'

    config_dict = set_up_config_dict(
        config_path, train_subjects, test_subjects, job_identifier,
        batch_size_test, dataset_path, input_to_get, output_to_get,
        train_subjects_model, test_subjects_model, config_file_model,
        job_identifier_encdec, epoch_encdec)

    ignite = IgniteTestNVS()
    model, data_loader, config_dict = ignite.run(config_dict)
    data_iterator = iter(data_loader)

    for input_dict, label_dict in data_iterator:
        input_dict['bg_crop'] = torch.ones(input_dict['img_crop'].size())
        # torch.max(input_dict['img_crop'])
        input_dict_cuda, label_dict_cuda = rhodin_utils_datasets.nestedDictToDevice(
            (input_dict, label_dict), device=device)
        output_dict_cuda = model(input_dict_cuda)
        utils_plot_batch.plot_iol(input_dict_cuda, label_dict_cuda,
                                  output_dict_cuda, config_dict, 'train',
                                  '../scratch/try_it_out_samebg.jpg')
        break
Exemple #6
0
    def _update(engine, batch):
        model.train()
        # print ('engine.state.iteration',engine.state.iteration)
        if not engine.state.iteration % backward_every:
            # print ('zero')
            optimizer.zero_grad()

        x, y = utils_data.nestedDictToDevice(
            batch, device=device)  # make it work for dict input too
        if forward_fn is None:
            y_pred = model(x)
        else:
            y_pred = forward_fn(x)

        loss = loss_fn(y_pred, y) / backward_every
        loss.backward()

        if not engine.state.iteration % backward_every:
            # print ('step')
            optimizer.step()

        return loss.item(), y_pred