def get_training_set(opt, spatial_transform, temporal_transform,
                     target_transform):
    assert opt.dataset in ['kinetics', 'activitynet', 'ucf101', 'hmdb51']

    if opt.dataset == 'kinetics':
        training_data = Kinetics(opt.video_path,
                                 opt.annotation_path,
                                 'training',
                                 spatial_transform=spatial_transform,
                                 temporal_transform=temporal_transform,
                                 target_transform=target_transform)
    elif opt.dataset == 'activitynet':
        training_data = ActivityNet(opt.video_path,
                                    opt.annotation_path,
                                    'training',
                                    False,
                                    spatial_transform=spatial_transform,
                                    temporal_transform=temporal_transform,
                                    target_transform=target_transform)
    elif opt.dataset == 'ucf101':
        training_data = UCF101(opt.video_path,
                               opt.annotation_path,
                               'training',
                               spatial_transform=spatial_transform,
                               temporal_transform=temporal_transform,
                               target_transform=target_transform)
    elif opt.dataset == 'hmdb51':
        training_data = HMDB51(opt.video_path,
                               opt.annotation_path,
                               'training',
                               spatial_transform=spatial_transform,
                               temporal_transform=temporal_transform,
                               target_transform=target_transform)

    return training_data
Ejemplo n.º 2
0
def get_training_set(opt, spatial_transform, temporal_transform,
                     target_transform):
    assert opt.dataset in ['kinetics', 'jester', 'ucf101']

    if opt.dataset == 'kinetics':
        training_data = Kinetics(opt.video_path,
                                 opt.annotation_path,
                                 'training',
                                 spatial_transform=spatial_transform,
                                 temporal_transform=temporal_transform,
                                 target_transform=target_transform,
                                 sample_duration=opt.sample_duration)
    elif opt.dataset == 'jester':
        training_data = Jester(opt.video_path,
                               opt.annotation_path,
                               'training',
                               spatial_transform=spatial_transform,
                               temporal_transform=temporal_transform,
                               target_transform=target_transform,
                               sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        training_data = UCF101(opt.video_path,
                               opt.annotation_path,
                               'training',
                               spatial_transform=spatial_transform,
                               temporal_transform=temporal_transform,
                               target_transform=target_transform,
                               sample_duration=opt.sample_duration)
    return training_data
Ejemplo n.º 3
0
def get_test_set(opt, spatial_transform, temporal_transform, target_transform):
    assert opt.dataset in ['kinetics', 'activitynet', 'ucf101', 'hmdb51', 'wedding']
    assert opt.test_subset in ['val', 'test']

    if opt.test_subset == 'val':
        subset = 'validation'
    elif opt.test_subset == 'test':
        subset = 'testing'
    if opt.dataset == 'kinetics':
        test_data = Kinetics(
            opt.video_path,
            opt.annotation_path,
            subset,
            0,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'activitynet':
        test_data = ActivityNet(
            opt.video_path,
            opt.annotation_path,
            subset,
            True,
            0,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        test_data = UCF101(
            opt.video_path,
            opt.annotation_path,
            subset,
            0,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'hmdb51':
        test_data = HMDB51(
            opt.video_path,
            opt.annotation_path,
            subset,
            0,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'wedding':
        test_data = Wedding(
            opt.video_path,
            opt.annotation_path,
            subset,
            0,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    return test_data
def get_validation_set(opt, spatial_transform, temporal_transform,
                       target_transform):
    assert opt.dataset in ['kinetics', 'ucf101', 'hmdb51', 'something']

    if opt.dataset == 'kinetics':
        validation_data = Kinetics(opt.video_path, opt.annotation_path,
                                   'validation', opt.n_val_samples,
                                   spatial_transform, temporal_transform,
                                   target_transform)
    elif opt.dataset == 'ucf101':
        validation_data = UCF101(opt.video_path, opt.annotation_path,
                                 'validation', opt.n_val_samples,
                                 spatial_transform, temporal_transform,
                                 target_transform)
    elif opt.dataset == 'hmdb51':
        validation_data = HMDB51(opt.video_path, opt.annotation_path,
                                 'validation', opt.n_val_samples,
                                 spatial_transform, temporal_transform,
                                 target_transform)
    elif opt.dataset == 'something':
        validation_data = Something(opt.video_path, opt.annotation_path,
                                    'validation', opt.n_val_samples,
                                    spatial_transform, temporal_transform,
                                    target_transform)
    return validation_data
Ejemplo n.º 5
0
def get_validation_set(opt, spatial_transform, temporal_transform,
                       target_transform):
    assert opt.dataset in ['kinetics', 'jester', 'ucf101']

    if opt.dataset == 'kinetics':
        validation_data = Kinetics(opt.video_path,
                                   opt.annotation_path,
                                   'validation',
                                   opt.n_val_samples,
                                   spatial_transform,
                                   temporal_transform,
                                   target_transform,
                                   sample_duration=opt.sample_duration)
    elif opt.dataset == 'jester':
        validation_data = Jester(opt.video_path,
                                 opt.annotation_path,
                                 'validation',
                                 opt.n_val_samples,
                                 spatial_transform,
                                 temporal_transform,
                                 target_transform,
                                 sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        validation_data = UCF101(opt.video_path,
                                 opt.annotation_path,
                                 'validation',
                                 opt.n_val_samples,
                                 spatial_transform,
                                 temporal_transform,
                                 target_transform,
                                 sample_duration=opt.sample_duration)
    return validation_data
Ejemplo n.º 6
0
def get_validation_set(opt,
                       spatial_transform,
                       temporal_transform,
                       target_transform,
                       score_sens_mode=False):
    assert opt.dataset in [
        'kinetics', 'activitynet', 'ucf101', 'hmdb51', 'something'
    ]

    if opt.dataset == 'kinetics':
        validation_data = Kinetics(opt.video_path,
                                   opt.annotation_path,
                                   'validation',
                                   opt.n_val_samples,
                                   spatial_transform,
                                   temporal_transform,
                                   target_transform,
                                   sample_duration=opt.sample_duration)
    elif opt.dataset == 'activitynet':
        validation_data = ActivityNet(opt.video_path,
                                      opt.annotation_path,
                                      'validation',
                                      opt.n_val_samples,
                                      spatial_transform,
                                      temporal_transform,
                                      target_transform,
                                      sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        validation_data = UCF101(opt.video_path,
                                 opt.annotation_path,
                                 'validation',
                                 opt.n_val_samples,
                                 spatial_transform,
                                 temporal_transform,
                                 target_transform,
                                 sample_duration=opt.sample_duration,
                                 score_sens_mode=score_sens_mode)
    elif opt.dataset == 'hmdb51':
        validation_data = HMDB51(opt.video_path,
                                 opt.annotation_path,
                                 'validation',
                                 opt.n_val_samples,
                                 spatial_transform,
                                 temporal_transform,
                                 target_transform,
                                 sample_duration=opt.sample_duration)
    elif opt.dataset == 'something':
        validation_data = Something(opt.video_path,
                                    opt.annotation_path,
                                    'validation',
                                    opt.n_val_samples,
                                    spatial_transform,
                                    temporal_transform,
                                    target_transform,
                                    sample_duration=opt.sample_duration,
                                    score_sens_mode=score_sens_mode)
    return validation_data
Ejemplo n.º 7
0
def get_test_set(opt, spatial_transform, temporal_transform, target_transform):
    assert opt.dataset in [
        'kinetics', 'jester', 'ucf101', 'egogesture', 'nvgesture'
    ]
    assert opt.test_subset in ['val', 'test']

    if opt.test_subset == 'val':
        subset = 'validation'
    elif opt.test_subset == 'test':
        subset = 'testing'
    if opt.dataset == 'kinetics':
        test_data = Kinetics(opt.video_path,
                             opt.annotation_path,
                             subset,
                             0,
                             spatial_transform,
                             temporal_transform,
                             target_transform,
                             sample_duration=opt.sample_duration)
    elif opt.dataset == 'jester':
        test_data = Jester(opt.video_path,
                           opt.annotation_path,
                           subset,
                           0,
                           spatial_transform,
                           temporal_transform,
                           target_transform,
                           sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        test_data = UCF101(opt.video_path,
                           opt.annotation_path,
                           subset,
                           0,
                           spatial_transform,
                           temporal_transform,
                           target_transform,
                           sample_duration=opt.sample_duration)
    elif opt.dataset == 'egogesture':
        test_data = EgoGesture(opt.video_path,
                               opt.annotation_path,
                               subset,
                               opt.n_val_samples,
                               spatial_transform,
                               temporal_transform,
                               target_transform,
                               modality=opt.modality,
                               sample_duration=opt.sample_duration)
    elif opt.dataset == 'nvgesture':
        test_data = NV(opt.video_path,
                       opt.annotation_path,
                       'validation',
                       spatial_transform=spatial_transform,
                       temporal_transform=temporal_transform,
                       target_transform=target_transform,
                       sample_duration=opt.sample_duration,
                       modality=opt.modality)
    return test_data
Ejemplo n.º 8
0
def get_validation_set(opt, spatial_transform, temporal_transform,
                       target_transform):
    assert opt.dataset in ['kinetics', 'activitynet', 'ucf101', 'hmdb51', 'grit']

    if opt.dataset == 'kinetics':
        validation_data = Kinetics(
            opt.video_path,
            opt.annotation_path,
            'validation',
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'activitynet':
        validation_data = ActivityNet(
            opt.video_path,
            opt.annotation_path,
            'validation',
            False,
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        validation_data = UCF101(
            opt.video_path,
            opt.annotation_path,
            'validation',
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'hmdb51':
        validation_data = HMDB51(
            opt.video_path,
            opt.annotation_path,
            'validation',
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'grit':
        validation_data = GRIT(
            opt.video_path,
            opt.annotation_path,
            'validation',
            opt.sample_duration,
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform)

    return validation_data
Ejemplo n.º 9
0
def get_training_set(opt, spatial_transform, temporal_transform,
                     target_transform):
    assert opt.dataset in ['kinetics', 'activitynet', 'ucf101', 'hmdb51','something','fire']

    if opt.dataset == 'kinetics':
        training_data = Kinetics(
            opt.video_path+"/train_256",
            opt.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)
    elif opt.dataset == 'activitynet':
        training_data = ActivityNet(
            opt.video_path,
            opt.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)
    elif opt.dataset == 'ucf101':
        opt.annotation_path = opt.annotation_path + "/train_rgb_ucf101.txt"
        training_data = UCF101(
            opt.video_path,
            opt.annotation_path,
            num_segments = opt.num_segments,
            modality = opt.modality,
            transform = spatial_transform)
    elif opt.dataset == 'hmdb51':
        opt.annotation_path = opt.annotation_path + "/train_rgb_hmdb51.txt"
        training_data = HMDB51(
            opt.video_path,
            opt.annotation_path,
            num_segments = opt.num_segments,
            modality = opt.modality, 
            transform = spatial_transform)
    elif opt.dataset == 'something':
        training_data = Something(
            opt.video_path,
            opt.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,                                                            
            target_transform=target_transform)
    elif opt.dataset == 'fire':
        opt.annotation_path = opt.annotation_path + "/train_fire.txt"
        training_data = FIRE(
            opt.video_path,
            opt.annotation_path,
            num_segments = opt.num_segments,
            modality = opt.modality,
            transform = spatial_transform)


    return training_data
Ejemplo n.º 10
0
def get_validation_set(opt, spatial_transform, temporal_transform,
                       target_transform, image_type):
    assert opt.dataset in [
        'kinetics', 'activitynet', 'ucf101', 'hmdb51', 'synthetic'
    ]

    if opt.dataset == 'kinetics':
        validation_data = Kinetics(opt.video_path,
                                   opt.annotation_path,
                                   'validation',
                                   opt.n_val_samples,
                                   spatial_transform,
                                   temporal_transform,
                                   target_transform,
                                   sample_duration=opt.sample_duration)
    elif opt.dataset == 'activitynet':
        validation_data = ActivityNet(opt.video_path,
                                      opt.annotation_path,
                                      'validation',
                                      False,
                                      opt.n_val_samples,
                                      spatial_transform,
                                      temporal_transform,
                                      target_transform,
                                      sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        validation_data = UCF101(opt.video_path,
                                 opt.annotation_path,
                                 'validation',
                                 opt.n_val_samples,
                                 spatial_transform,
                                 temporal_transform,
                                 target_transform,
                                 sample_duration=opt.sample_duration)
    elif opt.dataset == 'hmdb51':
        validation_data = HMDB51(opt.video_path,
                                 opt.annotation_path,
                                 'validation',
                                 opt.n_val_samples,
                                 spatial_transform,
                                 temporal_transform,
                                 target_transform,
                                 sample_duration=opt.sample_duration)
    elif opt.dataset == 'synthetic':
        validation_data = Synthetic(opt.video_path,
                                    opt.annotation_path,
                                    'validation',
                                    opt.n_val_samples,
                                    spatial_transform,
                                    temporal_transform,
                                    target_transform,
                                    sample_duration=opt.sample_duration,
                                    channel_fuse_step=opt.channel_fuse,
                                    image_type=image_type)
    return validation_data
Ejemplo n.º 11
0
def get_validation_set(config, spatial_transform, temporal_transform, target_transform):

    assert config.dataset in ['kinetics', 'activitynet', 'ucf101', 'blender']

    # Disable evaluation
    if config.no_eval:
        return None

    if config.dataset == 'kinetics':

        validation_data = Kinetics(
            config.video_path,
            config.annotation_path,
            'validation',
            config.num_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=config.sample_duration)

    elif config.dataset == 'activitynet':

        validation_data = ActivityNet(
            config.video_path,
            config.annotation_path,
            'validation',
            False,
            config.num_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=config.sample_duration)

    elif config.dataset == 'ucf101':

        validation_data = UCF101(
            config.video_path,
            config.annotation_path,
            'validation',
            config.num_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=config.sample_duration)

    elif config.dataset == 'blender':

        validation_data = BlenderSyntheticDataset(
            root_path=config.video_path,
            subset='validation',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)

    return validation_data
Ejemplo n.º 12
0
def get_training_set(opt, spatial_transform, temporal_transform,
                     target_transform):
    assert opt.dataset in [
        'kinetics', 'jester', 'ucf101', 'egogesture', 'nvgesture'
    ]

    if opt.train_validate:
        subset = ['training', 'validation']
    else:
        subset = 'training'

    if opt.dataset == 'kinetics':
        training_data = Kinetics(opt.video_path,
                                 opt.annotation_path,
                                 'training',
                                 spatial_transform=spatial_transform,
                                 temporal_transform=temporal_transform,
                                 target_transform=target_transform,
                                 sample_duration=opt.sample_duration)
    elif opt.dataset == 'jester':
        training_data = Jester(opt.video_path,
                               opt.annotation_path,
                               'training',
                               spatial_transform=spatial_transform,
                               temporal_transform=temporal_transform,
                               target_transform=target_transform,
                               sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        training_data = UCF101(opt.video_path,
                               opt.annotation_path,
                               'training',
                               spatial_transform=spatial_transform,
                               temporal_transform=temporal_transform,
                               target_transform=target_transform,
                               sample_duration=opt.sample_duration)
    elif opt.dataset == 'egogesture':
        training_data = EgoGesture(opt.video_path,
                                   opt.annotation_path,
                                   subset,
                                   spatial_transform=spatial_transform,
                                   temporal_transform=temporal_transform,
                                   target_transform=target_transform,
                                   sample_duration=opt.sample_duration,
                                   modality=opt.modality)
    elif opt.dataset == 'nvgesture':
        training_data = NV(opt.video_path,
                           opt.annotation_path,
                           subset,
                           spatial_transform=spatial_transform,
                           temporal_transform=temporal_transform,
                           target_transform=target_transform,
                           sample_duration=opt.sample_duration,
                           modality=opt.modality)
    return training_data
def get_test_set(opt, spatial_transform, temporal_transform, target_transform):
    assert opt.dataset in ['kinetics', 'ucf101', 'hmdb51', 'something']
    assert opt.test_subset in ['val', 'test']

    if opt.test_subset == 'val':
        subset = 'validation'
    elif opt.test_subset == 'test':
        subset = 'testing'
    if opt.dataset == 'kinetics':
        test_data = Kinetics(opt.video_path,
                             opt.annotation_path,
                             subset,
                             0,
                             spatial_transform,
                             temporal_transform,
                             target_transform,
                             sample_duration=opt.sample_duration,
                             n_test_clips_for_each_video=opt.n_test_clips,
                             n_test_crops_for_each_video=opt.n_test_crops)
    elif opt.dataset == 'ucf101':
        test_data = UCF101(opt.video_path,
                           opt.annotation_path,
                           subset,
                           0,
                           spatial_transform,
                           temporal_transform,
                           target_transform,
                           sample_duration=opt.sample_duration,
                           n_test_clips_for_each_video=opt.n_test_clips,
                           n_test_crops_for_each_video=opt.n_test_crops)
    elif opt.dataset == 'hmdb51':
        test_data = HMDB51(opt.video_path,
                           opt.annotation_path,
                           subset,
                           0,
                           spatial_transform,
                           temporal_transform,
                           target_transform,
                           sample_duration=opt.sample_duration,
                           n_test_clips_for_each_video=opt.n_test_clips,
                           n_test_crops_for_each_video=opt.n_test_crops)
    elif opt.dataset == 'something':
        test_data = Something(opt.video_path,
                              opt.annotation_path,
                              subset,
                              0,
                              spatial_transform,
                              temporal_transform,
                              target_transform,
                              sample_duration=opt.sample_duration,
                              n_test_clips_for_each_video=opt.n_test_clips,
                              n_test_crops_for_each_video=opt.n_test_crops)

    return test_data
Ejemplo n.º 14
0
def get_validation_set(opt, spatial_transform, temporal_transform,
                       target_transform):
    assert opt.dataset in ['kinetics', 'activitynet', 'ucf101', 'hmdb51', 'moments']

    if opt.dataset == 'kinetics':
        validation_data = Kinetics(
            opt.video_path,
            opt.annotation_path,
            'validation',
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'activitynet':
        validation_data = ActivityNet(
            opt.video_path,
            opt.annotation_path,
            'validation',
            False,
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        validation_data = UCF101(
            opt.video_path,
            opt.annotation_path,
            'validation',
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'hmdb51':
        validation_data = HMDB51(
            opt.video_path,
            opt.annotation_path,
            'validation',
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == "moments":
        validation_data = Moments(
            "/media/lili/fce9875a-a5c8-4c35-8f60-db60be29ea5d/Moments_in_Time_Raw/validation/",
            opt.annotation_path,
            'validation',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)
    return validation_data
Ejemplo n.º 15
0
def get_validation_set(opt, spatial_transform, temporal_transform,
                       target_transform):
    assert opt.dataset in [
        'kinetics', 'activitynet', 'ucf101', 'hmdb51', 'modelnet'
    ]

    if opt.dataset == 'kinetics':
        validation_data = Kinetics(opt.video_path,
                                   opt.annotation_path,
                                   'validation',
                                   opt.n_val_samples,
                                   spatial_transform,
                                   temporal_transform,
                                   target_transform,
                                   sample_duration=opt.sample_duration)
    elif opt.dataset == 'activitynet':
        validation_data = ActivityNet(opt.video_path,
                                      opt.annotation_path,
                                      'validation',
                                      False,
                                      opt.n_val_samples,
                                      spatial_transform,
                                      temporal_transform,
                                      target_transform,
                                      sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        validation_data = UCF101(opt.video_path,
                                 opt.annotation_path,
                                 'validation',
                                 opt.n_val_samples,
                                 spatial_transform,
                                 temporal_transform,
                                 target_transform,
                                 sample_duration=opt.sample_duration)
    elif opt.dataset == 'hmdb51':
        validation_data = HMDB51(opt.video_path,
                                 opt.annotation_path,
                                 'validation',
                                 opt.n_val_samples,
                                 spatial_transform,
                                 temporal_transform,
                                 target_transform,
                                 sample_duration=opt.sample_duration)
    elif opt.dataset == 'modelnet':
        if opt.video_path == 'modelnet10x12':
            data = np.load(opt.root_path + 'modelnet10_test_32.npz')
        elif opt.video_path == 'modelnet40x12':
            data = np.load(opt.root_path + 'modelnet40_test_32.npz')

        validation_data = modelnet(data)

    return validation_data
Ejemplo n.º 16
0
def get_test_set(config, spatial_transform, temporal_transform, target_transform):

    assert config.dataset in ['kinetics', 'activitynet', 'ucf101', 'blender']
    assert config.test_subset in ['val', 'test']

    if config.test_subset == 'val':
        subset = 'validation'
    elif config.test_subset == 'test':
        subset = 'testing'

    if config.dataset == 'kinetics':

        test_data = Kinetics(
            config.video_path,
            config.annotation_path,
            subset,
            0,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=config.sample_duration)

    elif config.dataset == 'activitynet':

        test_data = ActivityNet(
            config.video_path,
            config.annotation_path,
            subset,
            True,
            0,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=config.sample_duration)

    elif config.dataset == 'ucf101':

        test_data = UCF101(
            config.video_path,
            config.annotation_path,
            subset,
            0,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=config.sample_duration)

    return test_data
Ejemplo n.º 17
0
def get_training_set(opt, spatial_transform, temporal_transform,
                     target_transform):
    assert opt.dataset in ['kinetics', 'activitynet', 'ucf101', 'hmdb51', 'moments']

    if opt.dataset == 'kinetics':
        training_data = Kinetics(
            opt.video_path,
            opt.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)
    elif opt.dataset == 'activitynet':
        training_data = ActivityNet(
            opt.video_path,
            opt.annotation_path,
            'training',
            False,
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)
    elif opt.dataset == 'ucf101':
        training_data = UCF101(
            opt.video_path,
            opt.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)
    elif opt.dataset == 'hmdb51':
        training_data = HMDB51(
            opt.video_path,
            opt.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)
    elif opt.dataset == "moments":
        training_data = Moments(
            "/media/lili/fce9875a-a5c8-4c35-8f60-db60be29ea5d/Moments_in_Time_Raw/training/",
            opt.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)

    return training_data
Ejemplo n.º 18
0
def get_training_set(opt, spatial_transform, temporal_transform,
                     target_transform, image_type):
    assert opt.dataset in [
        'kinetics', 'activitynet', 'ucf101', 'hmdb51', 'synthetic'
    ]

    if opt.dataset == 'kinetics':
        training_data = Kinetics(opt.video_path,
                                 opt.annotation_path,
                                 'training',
                                 spatial_transform=spatial_transform,
                                 temporal_transform=temporal_transform,
                                 target_transform=target_transform)
    elif opt.dataset == 'activitynet':
        training_data = ActivityNet(opt.video_path,
                                    opt.annotation_path,
                                    'training',
                                    False,
                                    spatial_transform=spatial_transform,
                                    temporal_transform=temporal_transform,
                                    target_transform=target_transform)
    elif opt.dataset == 'ucf101':
        training_data = UCF101(opt.video_path,
                               opt.annotation_path,
                               'training',
                               spatial_transform=spatial_transform,
                               temporal_transform=temporal_transform,
                               target_transform=target_transform)
    elif opt.dataset == 'hmdb51':
        training_data = HMDB51(opt.video_path,
                               opt.annotation_path,
                               'training',
                               spatial_transform=spatial_transform,
                               temporal_transform=temporal_transform,
                               target_transform=target_transform)
    elif opt.dataset == 'synthetic':
        training_data = Synthetic(opt.video_path,
                                  opt.annotation_path,
                                  'training',
                                  spatial_transform=spatial_transform,
                                  temporal_transform=temporal_transform,
                                  target_transform=target_transform,
                                  channel_fuse_step=opt.channel_fuse,
                                  image_type=image_type)

    return training_data
Ejemplo n.º 19
0
def get_training_set(opt, spatial_transform, temporal_transform,
                     target_transform):
    assert opt.dataset in [
        'kinetics', 'activitynet', 'ucf101', 'hmdb51', 'modelnet'
    ]

    if opt.dataset == 'kinetics':
        training_data = Kinetics(
            opt.video_path,
            opt.annotation_path,
            'training',
            n_samples_for_each_video=opt.samples_per_video,
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)
    elif opt.dataset == 'activitynet':
        training_data = ActivityNet(opt.video_path,
                                    opt.annotation_path,
                                    'training',
                                    False,
                                    spatial_transform=spatial_transform,
                                    temporal_transform=temporal_transform,
                                    target_transform=target_transform)
    elif opt.dataset == 'ucf101':
        training_data = UCF101(opt.video_path,
                               opt.annotation_path,
                               'training',
                               spatial_transform=spatial_transform,
                               temporal_transform=temporal_transform,
                               target_transform=target_transform)
    elif opt.dataset == 'hmdb51':
        training_data = HMDB51(opt.video_path,
                               opt.annotation_path,
                               'training',
                               spatial_transform=spatial_transform,
                               temporal_transform=temporal_transform,
                               target_transform=target_transform)
    elif opt.dataset == 'modelnet':
        if opt.video_path == 'modelnet10x12':
            data = np.load(opt.root_path + 'modelnet10_train12_32.npz')
        elif opt.video_path == 'modelnet40x12':
            data = np.load(opt.root_path + 'modelnet40_train12_32.npz')
        #data = np.load(opt.root_path+'modelnet10_train_32.npz')
        training_data = modelnet(data)

    return training_data
Ejemplo n.º 20
0
def get_training_set(config, spatial_transform, temporal_transform, target_transform):

    assert config.dataset in ['kinetics', 'activitynet', 'ucf101', 'blender']

    if config.dataset == 'kinetics':

        training_data = Kinetics(
            config.video_path,
            config.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)

    elif config.dataset == 'activitynet':

        training_data = ActivityNet(
            config.video_path,
            config.annotation_path,
            'training',
            False,
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)

    elif config.dataset == 'ucf101':

        training_data = UCF101(
            config.video_path,
            config.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)

    elif config.dataset == 'blender':

        training_data = BlenderSyntheticDataset(
            root_path=config.video_path,
            subset='train',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)

    return training_data
Ejemplo n.º 21
0
def get_test_set(opt, spatial_transform, temporal_transform, target_transform):
    assert opt.dataset in ['kinetics', 'jester', 'ucf101', 'dad']
    assert opt.test_subset in ['val', 'test']

    if opt.test_subset == 'val':
        subset = 'validation'
    elif opt.test_subset == 'test':
        subset = 'testing'
    if opt.dataset == 'kinetics':
        test_data = Kinetics(opt.video_path,
                             opt.annotation_path,
                             subset,
                             0,
                             spatial_transform,
                             temporal_transform,
                             target_transform,
                             sample_duration=opt.sample_duration)
    elif opt.dataset == 'jester':
        test_data = Jester(opt.video_path,
                           opt.annotation_path,
                           subset,
                           0,
                           spatial_transform,
                           temporal_transform,
                           target_transform,
                           sample_duration=opt.sample_duration)
    elif opt.dataset == 'dad':
        test_data = Dad(opt.video_path,
                        opt.annotation_path,
                        subset,
                        0,
                        spatial_transform,
                        temporal_transform,
                        target_transform,
                        sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        test_data = UCF101(opt.video_path,
                           opt.annotation_path,
                           subset,
                           0,
                           spatial_transform,
                           temporal_transform,
                           target_transform,
                           sample_duration=opt.sample_duration)
    return test_data
def get_training_set(opt, spatial_transform, temporal_transform,
                     target_transform):
    assert opt.dataset in [
        'kinetics', 'activitynet', 'ucf101', 'hmdb51', 'moments'
    ]

    if opt.dataset == 'kinetics':
        training_data = Kinetics(opt.video_path,
                                 opt.annotation_path,
                                 'training',
                                 spatial_transform=spatial_transform,
                                 temporal_transform=temporal_transform,
                                 target_transform=target_transform)
    elif opt.dataset == 'activitynet':
        training_data = ActivityNet(opt.video_path,
                                    opt.annotation_path,
                                    'training',
                                    False,
                                    spatial_transform=spatial_transform,
                                    temporal_transform=temporal_transform,
                                    target_transform=target_transform)
    elif opt.dataset == 'ucf101':
        training_data = UCF101(opt.video_path,
                               opt.annotation_path,
                               'training',
                               spatial_transform=spatial_transform,
                               temporal_transform=temporal_transform,
                               target_transform=target_transform)
    elif opt.dataset == 'hmdb51':
        training_data = HMDB51(opt.video_path,
                               opt.annotation_path,
                               'training',
                               spatial_transform=spatial_transform,
                               temporal_transform=temporal_transform,
                               target_transform=target_transform)
    elif opt.dataset == "moments":
        training_data = Moments(
            "/ssd/Lili/Moments_raw_imgs/Moments_in_Time_Raw/training/",
            opt.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)

    return training_data
Ejemplo n.º 23
0
def get_test_set(opt, spatial_transform, temporal_transform, target_transform):
    assert opt.dataset in ['kinetics', 'ucf101', 'hmdb51']
    assert opt.test_subset in ['val', 'test']

    if opt.test_subset == 'val':
        subset = 'validation'
    elif opt.test_subset == 'test':
        subset = 'testing'
    if opt.dataset == 'kinetics':
        test_data = Kinetics(opt.video_path,
                             opt.annotation_path,
                             subset,
                             0,
                             spatial_transform,
                             temporal_transform,
                             target_transform,
                             sample_duration=opt.sample_duration,
                             num_vid_samples=5)
    elif opt.dataset == 'ucf101':
        test_data = UCF101(opt.video_path,
                           opt.annotation_path,
                           subset,
                           1,
                           spatial_transform,
                           temporal_transform,
                           target_transform,
                           sample_duration=opt.sample_duration,
                           num_vid_samples=5)
    elif opt.dataset == 'hmdb51':
        test_data = HMDB51(opt.video_path,
                           opt.annotation_path,
                           subset,
                           1,
                           spatial_transform,
                           temporal_transform,
                           target_transform,
                           sample_duration=opt.sample_duration,
                           num_vid_samples=5)

    return test_data
Ejemplo n.º 24
0
def get_test_set(opt,
                 spatial_transform,
                 temporal_transform,
                 target_transform,
                 spatio_temporal_transform=None):
    assert opt.dataset in [
        'kinetics',
        'activitynet',
        'ucf101',
        'hmdb51',
        'kth',
        'kth2',
        'sth',
        'sth_init',
        'gtea',
        'jester',
        'ucf50',
        'ucf50_color',
        'real',
    ]
    assert opt.test_subset in ['val', 'test']

    if opt.test_subset == 'val':
        subset = 'validation'
    elif opt.test_subset == 'test':
        subset = 'testing'
    if opt.dataset == 'kinetics':
        test_data = Kinetics(opt.video_path,
                             opt.annotation_path,
                             subset,
                             0,
                             spatial_transform,
                             temporal_transform,
                             target_transform,
                             sample_duration=opt.sample_duration)
    elif opt.dataset == 'activitynet':
        test_data = ActivityNet(opt.video_path,
                                opt.annotation_path,
                                subset,
                                True,
                                0,
                                spatial_transform,
                                temporal_transform,
                                target_transform,
                                sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        test_data = UCF101(opt.video_path,
                           opt.annotation_path,
                           subset,
                           10,
                           spatial_transform=spatial_transform,
                           temporal_transform=temporal_transform,
                           spatio_temporal_transform=spatio_temporal_transform,
                           target_transform=target_transform,
                           sample_duration=opt.sample_duration)
    elif opt.dataset == 'hmdb51':
        test_data = HMDB51(opt.video_path,
                           opt.annotation_path,
                           subset,
                           0,
                           spatial_transform=spatial_transform,
                           temporal_transform=temporal_transform,
                           spatio_temporal_transform=spatio_temporal_transform,
                           target_transform=target_transform,
                           sample_duration=opt.sample_duration)
    elif opt.dataset == 'kth':
        test_data = KTH(opt.video_path,
                        opt.annotation_path,
                        subset,
                        0,
                        spatial_transform=spatial_transform,
                        temporal_transform=temporal_transform,
                        spatio_temporal_transform=spatio_temporal_transform,
                        target_transform=target_transform,
                        sample_duration=opt.sample_duration)
    elif opt.dataset == 'kth2':
        test_data = KTH2(opt.video_path,
                         opt.annotation_path,
                         subset,
                         0,
                         spatial_transform=spatial_transform,
                         temporal_transform=temporal_transform,
                         spatio_temporal_transform=spatio_temporal_transform,
                         target_transform=target_transform,
                         sample_duration=opt.sample_duration)
    elif opt.dataset == 'sth':
        test_data = Something2(
            opt.video_path,
            opt.annotation_path,
            subset,
            0,
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            spatio_temporal_transform=spatio_temporal_transform,
            target_transform=target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'jester':
        test_data = Jester(opt.video_path,
                           opt.annotation_path,
                           subset,
                           0,
                           spatial_transform=spatial_transform,
                           temporal_transform=temporal_transform,
                           spatio_temporal_transform=spatio_temporal_transform,
                           target_transform=target_transform,
                           sample_duration=opt.sample_duration)
    elif opt.dataset == 'sth_init':
        test_data = Something2Init(
            opt.video_path,
            opt.annotation_path,
            subset,
            0,
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            spatio_temporal_transform=spatio_temporal_transform,
            target_transform=target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'gtea':
        test_data = GTEA(opt.video_path,
                         opt.annotation_path,
                         subset,
                         0,
                         spatial_transform=spatial_transform,
                         temporal_transform=temporal_transform,
                         spatio_temporal_transform=spatio_temporal_transform,
                         target_transform=target_transform,
                         sample_duration=opt.sample_duration,
                         test_split=opt.test_split)
    elif opt.dataset == 'ucf50':
        test_data = UCF50(opt.video_path,
                          opt.annotation_path,
                          subset,
                          0,
                          spatial_transform=spatial_transform,
                          temporal_transform=temporal_transform,
                          spatio_temporal_transform=spatio_temporal_transform,
                          target_transform=target_transform,
                          sample_duration=opt.sample_duration,
                          test_split=opt.test_split)
    elif opt.dataset == 'ucf50_color':
        test_data = UCF50(opt.video_path,
                          opt.annotation_path,
                          subset,
                          0,
                          spatial_transform=spatial_transform,
                          temporal_transform=temporal_transform,
                          spatio_temporal_transform=spatio_temporal_transform,
                          target_transform=target_transform,
                          sample_duration=opt.sample_duration,
                          test_split=opt.test_split)
    elif opt.dataset == 'real':
        test_data = REAL(opt.video_path,
                         opt.annotation_path,
                         subset,
                         0,
                         spatial_transform=spatial_transform,
                         temporal_transform=temporal_transform,
                         spatio_temporal_transform=spatio_temporal_transform,
                         target_transform=target_transform,
                         sample_duration=opt.sample_duration)

    return test_data
Ejemplo n.º 25
0
def get_test_set(opt, spatial_transform, temporal_transform, target_transform,
                 image_type):
    assert opt.dataset in [
        'kinetics', 'activitynet', 'ucf101', 'hmdb51', 'synthetic', 'vlog'
    ]
    assert opt.test_subset in ['val', 'test']

    if opt.test_subset == 'val':
        subset = 'validation'
    elif opt.test_subset == 'test':
        subset = 'testing'

    if opt.dataset == 'kinetics':
        test_data = Kinetics(opt.video_path,
                             opt.annotation_path,
                             subset,
                             0,
                             spatial_transform,
                             temporal_transform,
                             target_transform,
                             sample_duration=opt.sample_duration)
    elif opt.dataset == 'activitynet':
        test_data = ActivityNet(opt.video_path,
                                opt.annotation_path,
                                subset,
                                True,
                                0,
                                spatial_transform,
                                temporal_transform,
                                target_transform,
                                sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        test_data = UCF101(opt.video_path,
                           opt.annotation_path,
                           subset,
                           0,
                           spatial_transform,
                           temporal_transform,
                           target_transform,
                           sample_duration=opt.sample_duration)
    elif opt.dataset == 'hmdb51':
        test_data = HMDB51(opt.video_path,
                           opt.annotation_path,
                           subset,
                           0,
                           spatial_transform,
                           temporal_transform,
                           target_transform,
                           sample_duration=opt.sample_duration)
    elif opt.dataset == 'synthetic':
        test_data = Synthetic(opt.video_path,
                              opt.annotation_path,
                              subset,
                              1,
                              spatial_transform,
                              temporal_transform,
                              target_transform,
                              sample_duration=opt.sample_duration,
                              channel_fuse_step=opt.channel_fuse,
                              image_type=image_type)
    elif opt.dataset == 'vlog':
        test_data = Vlog(opt.video_path,
                         opt.annotation_path,
                         subset,
                         1,
                         spatial_transform,
                         temporal_transform,
                         target_transform,
                         sample_duration=opt.sample_duration,
                         image_type=image_type)

    return test_data
Ejemplo n.º 26
0
def get_test_set(opt,
                 spatial_transform,
                 temporal_transform,
                 target_transform,
                 score_sens_mode=False,
                 score_inf_mode=False,
                 inner_temp_transform=None):
    assert opt.dataset in [
        'kinetics', 'activitynet', 'ucf101', 'hmdb51', 'something'
    ]
    assert opt.test_subset in ['val', 'test']

    if opt.test_subset == 'val':
        subset = 'validation'
    elif opt.test_subset == 'test':
        subset = 'testing'
    if opt.dataset == 'kinetics':
        test_data = Kinetics(opt.video_path,
                             opt.annotation_path,
                             subset,
                             0,
                             spatial_transform,
                             temporal_transform,
                             target_transform,
                             sample_duration=opt.sample_duration,
                             sample_stride=opt.sample_stride)
    elif opt.dataset == 'activitynet':
        test_data = ActivityNet(opt.video_path,
                                opt.annotation_path,
                                subset,
                                0,
                                spatial_transform,
                                temporal_transform,
                                target_transform,
                                sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        test_data = UCF101(
            opt.video_path,
            opt.annotation_path,
            subset,
            # 0,
            1,  # sample 1 clip each video
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration,
            score_sens_mode=score_sens_mode,
            score_inf_mode=score_inf_mode)
    elif opt.dataset == 'hmdb51':
        test_data = HMDB51(opt.video_path,
                           opt.annotation_path,
                           subset,
                           0,
                           spatial_transform,
                           temporal_transform,
                           target_transform,
                           sample_duration=opt.sample_duration)
    elif opt.dataset == 'something':
        test_data = Something(
            opt.video_path,
            opt.annotation_path,
            subset,
            # 0,
            1,  # sample 1 clip each video
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration,
            score_sens_mode=score_sens_mode,
            score_inf_mode=score_inf_mode,
            inner_temp_transform=inner_temp_transform)

    return test_data
Ejemplo n.º 27
0
def get_test_set(opt, spatial_transform, temporal_transform, target_transform):
    assert opt.dataset in ['kinetics', 'activitynet', 'ucf101', 'hmdb51','something','fire']
    assert opt.test_subset in ['val', 'test']

    if opt.test_subset == 'val':
        subset = 'validation'
    elif opt.test_subset == 'test':
        subset = 'testing'
    if opt.dataset == 'kinetics':
        test_data = Kinetics(
            opt.video_path,
            opt.annotation_path,
            subset,
            0,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration,
            sample_stride=opt.sample_stride)
    elif opt.dataset == 'activitynet':
        test_data = ActivityNet(
            opt.video_path,
            opt.annotation_path,
            subset,
            0,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        opt.annotation_path = opt.annotation_path + "/test_rgb_ucf101.txt"
        test_data = UCF101(
            opt.video_path,
            opt.annotation_path,
            num_segments = opt.num_segments,
            modality = opt.modality,
            transform = spatial_transform,
            test_mode = True)
    elif opt.dataset == 'hmdb51':
        test_data = HMDB51(
            opt.video_path,
            opt.annotation_path,
            subset,
            0,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'something':                                                                                                                    
        test_data = Something(                                                                                                                          
            opt.video_path,                                                                                                                          
            opt.annotation_path,                                                                                                                     
            subset,                                                                                                                                  
            0,                                                                                                                                       
            spatial_transform,                                                                                                                       
            temporal_transform,                                                                                                                      
            target_transform,                                                                                                                        
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'fire':
        opt.annotation_path = "/DATACENTER2/wxy/workspace/senet-3d/datasets/txt/test_fire.txt"
        test_data = FIRE(
            opt.video_path,
            opt.annotation_path,
            num_segments = opt.num_segments,
            modality = opt.modality,
            transform = spatial_transform,
            test_mode=True,
            test_idx=opt.test_idx)

    return test_data
Ejemplo n.º 28
0
def get_validation_set(opt, spatial_transform, temporal_transform,
                       target_transform):
    assert opt.dataset in ['kinetics', 'kinetics_adv', 'kinetics_bkgmsk', 'kinetics_human_msk', 'kinetics_adv_msk', 'activitynet', 'ucf101', 'hmdb51', 'diving48']

    if opt.dataset == 'kinetics':
        validation_data = Kinetics(
            opt.video_path+'/val',
            opt.annotation_path,
            'validation',
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'kinetics_adv':
        validation_data = Kinetics_adv(
            opt.video_path+'/val',
            opt.annotation_path,
            'validation',
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration,
            place_pred_path=opt.place_pred_path,
            is_place_soft_label=opt.is_place_soft)      
    elif opt.dataset == 'kinetics_bkgmsk':
        validation_data = Kinetics_bkgmsk(
            opt.video_path+'/val',
            opt.annotation_path,
            'validation',
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration,
            detection_path=opt.human_dets_path,
            mask_ratio=opt.mask_ratio)                  
    elif opt.dataset == 'kinetics_adv_msk':
        validation_data_1 = Kinetics_adv(
            opt.video_path+'/val',
            opt.annotation_path,
            'validation',
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration,
            place_pred_path=opt.place_pred_path,
            is_place_soft_label=opt.is_place_soft)     
        validation_data_2 = Kinetics_human_msk(
            opt.video_path+'/val',
            opt.annotation_path,
            'validation',
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration,
            detection_path=opt.human_dets_path,
            mask_ratio=opt.mask_ratio)                   
        validation_data = [validation_data_1, validation_data_2]
    elif opt.dataset == 'activitynet':
        validation_data = ActivityNet(
            opt.video_path,
            opt.annotation_path,
            'validation',
            False,
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        validation_data = UCF101(
            opt.video_path,
            opt.annotation_path,
            'validation',
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration,
            vis=opt.vis)
    elif opt.dataset == 'hmdb51':
        validation_data = HMDB51(
            opt.video_path,
            opt.annotation_path,
            'validation',
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration,
            vis=opt.vis)
    elif opt.dataset == 'diving48':
        validation_data = Diving48(
            opt.video_path,
            opt.annotation_path,
            'validation',
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration,
            vis=opt.vis)            
    return validation_data
Ejemplo n.º 29
0
def get_training_set(opt, spatial_transform, temporal_transform,
                     target_transform):
    assert opt.dataset in ['kinetics', 'kinetics_adv', 'kinetics_bkgmsk', 'kinetics_adv_msk', 'activitynet', 'ucf101', 'hmdb51', 'diving48']

    if opt.dataset == 'kinetics':
        training_data = Kinetics(
            opt.video_path+'/train',
            opt.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)
    elif opt.dataset == 'kinetics_adv':
        training_data = Kinetics_adv(
            opt.video_path+'/train',
            opt.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform,
            place_pred_path=opt.place_pred_path,
            is_place_soft_label=opt.is_place_soft)      
    elif opt.dataset == 'kinetics_bkgmsk':
        training_data = Kinetics_bkgmsk(
            opt.video_path+'/train',
            opt.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform,
            detection_path=opt.human_dets_path,
            mask_ratio=opt.mask_ratio)            
    elif opt.dataset == 'kinetics_adv_msk':    
        training_data_1 = Kinetics_adv(
            opt.video_path+'/train',
            opt.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform,
            place_pred_path=opt.place_pred_path,
            is_place_soft_label=opt.is_place_soft)   
        training_data_2 = Kinetics_human_msk(
            opt.video_path+'/train',
            opt.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform,
            detection_path=opt.human_dets_path,
            mask_ratio=opt.mask_ratio)         
        training_data = [training_data_1, training_data_2]
    elif opt.dataset == 'activitynet':
        training_data = ActivityNet(
            opt.video_path,
            opt.annotation_path,
            'training',
            False,
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)
    elif opt.dataset == 'ucf101':
        training_data = UCF101(
            opt.video_path,
            opt.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)
    elif opt.dataset == 'hmdb51':
        training_data = HMDB51(
            opt.video_path,
            opt.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)
    elif opt.dataset == 'diving48':
        training_data = Diving48(
            opt.video_path,
            opt.annotation_path,
            'training',
            spatial_transform=spatial_transform,
            temporal_transform=temporal_transform,
            target_transform=target_transform)

    return training_data
Ejemplo n.º 30
0
def get_validation_set(opt, spatial_transform, temporal_transform,
                       target_transform):
    assert opt.dataset in ['kinetics', 'activitynet', 'ucf101', 'hmdb51','something','fire']

    if opt.dataset == 'kinetics':
        validation_data = Kinetics(
            opt.video_path+"/val_256",
            opt.annotation_path,
            'validation',
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'activitynet':
        validation_data = ActivityNet(
            opt.video_path,
            opt.annotation_path,
            'validation',
            opt.n_val_samples,
            spatial_transform,
            temporal_transform,
            target_transform,
            sample_duration=opt.sample_duration)
    elif opt.dataset == 'ucf101':
        opt.annotation_path = opt.annotation_path.replace("train","test")
        #opt.annotation_path = opt.annotation_path + "/test_rgb_ucf101.txt"
        validation_data = UCF101(
            opt.video_path,
            opt.annotation_path,
            num_segments = opt.num_segments,
            modality = opt.modality,
            transform = spatial_transform,
            test_mode = True)
    elif opt.dataset == 'hmdb51':
        opt.annotation_path = opt.annotation_path.replace("train","val")
        validation_data = HMDB51(
            opt.video_path,
            opt.annotation_path,
            num_segments = opt.num_segments,
            modality = opt.modality,
            transform = spatial_transform)
    elif opt.dataset == 'fire':
        opt.annotation_path = opt.annotation_path.replace("train","test")
        validation_data = FIRE(
            opt.video_path,
            opt.annotation_path,
            num_segments = opt.num_segments,
            modality = opt.modality,
            transform = spatial_transform)
    elif opt.dataset == 'something':
        validation_data = Something(
            opt.video_path,
            opt.annotation_path,
            'validation',                                                                                                                            
            opt.n_val_samples,                                                                                                                       
            spatial_transform,                                                                                                                       
            temporal_transform,                                                                                                                      
            target_transform,                                                                                                                        
            sample_duration=opt.sample_duration)  
    return validation_data