def download(self): import zipfile import shutil if self._check_integrity(): return for name in self.zips_md5: zip_filename = '{0}.zip'.format(name) filename = os.path.join(self.root, zip_filename) if os.path.isfile(filename): continue url = '{0}/{1}'.format(self.download_url_prefix, zip_filename) download_url(url, self.root, zip_filename, self.zips_md5[name]) with zipfile.ZipFile(filename, 'r') as f: f.extractall(self.root) filename = os.path.join(self.root, self.filename) with h5py.File(filename, 'w') as f: for name in self.zips_md5: group = f.create_group(name) alphabets = list_dir(os.path.join(self.root, name)) characters = [(name, alphabet, character) for alphabet in alphabets for character in list_dir(os.path.join(self.root, name, alphabet))] split = 'train' if name == 'images_background' else 'test' labels_filename = os.path.join(self.root, self.filename_labels.format('', split)) with open(labels_filename, 'w') as f_labels: labels = sorted(characters) json.dump(labels, f_labels) for _, alphabet, character in characters: filenames = glob.glob(os.path.join(self.root, name, alphabet, character, '*.png')) dataset = group.create_dataset('{0}/{1}'.format(alphabet, character), (len(filenames), 105, 105), dtype='uint8') for i, char_filename in enumerate(filenames): image = Image.open(char_filename, mode='r').convert('L') dataset[i] = ImageOps.invert(image) shutil.rmtree(os.path.join(self.root, name)) for split in ['train', 'val', 'test']: filename = os.path.join(self.root, self.filename_labels.format( 'vinyals_', split)) data = get_asset(self.folder, '{0}.json'.format(split), dtype='json') with open(filename, 'w') as f: labels = sorted([('images_{0}'.format(name), alphabet, character) for (name, alphabets) in data.items() for (alphabet, characters) in alphabets.items() for character in characters]) json.dump(labels, f)
def __init__(self, root, alphabets, num_classes=None, hold_out=None, transform=None, seed=None): self.root = join(os.path.expanduser(root), self.folder) self.alphabets = alphabets self.num_classes = num_classes self.hold_out = hold_out self.transform = transform self.target_transform = None self.seed = seed self.target_folder = join(self.root, self.target_folder) self._alphabets = [ a for a in list_dir(self.target_folder) if a in self.alphabets ] self._characters = sum( [[join(a, c) for c in list_dir(join(self.target_folder, a))] for a in self._alphabets], []) if seed: random.seed(seed) random.shuffle(self._characters) if self.num_classes: self._characters = self._characters[:num_classes] self._character_images = [[ (image, idx) for image in list_files( join(self.target_folder, character), '.png') ] for idx, character in enumerate(self._characters)] self._train_character_images = [] self._val_character_images = [] for idx, character in enumerate(self._characters): train_characters = [] val_characters = [] for img_count, image in enumerate( list_files(join(self.target_folder, character), '.png')): if hold_out and img_count < hold_out: val_characters.append((image, idx)) else: train_characters.append((image, idx)) self._train_character_images.append(train_characters) self._val_character_images.append(val_characters) self._flat_train_character_images = sum(self._train_character_images, []) self._flat_val_character_images = sum(self._val_character_images, []) self._train = True self._set_images()
def __init__(self, root="./data", num_pretrain_alphabets=1, num_classes=None, transform=DEFAULT_TRANSFORM, seed=1, **kwargs): self.root = root self.num_pretrain_alphabets = num_pretrain_alphabets self.transform = transform self.seed = seed self.kwargs = kwargs path = join(join(os.path.expanduser(self.root), self.folder), self.target_folder) alphabets = list_dir(path) if num_classes: alphabets = [ a for a in alphabets if len(list_dir(join(path, a))) >= num_classes ] assert self.num_pretrain_alphabets + TEST < len( alphabets), 'cannot create test set' random.seed(self.seed) random.shuffle(alphabets) trs = self.num_pretrain_alphabets tes = trs + TEST train = alphabets[:trs] test = alphabets[trs:tes] val = alphabets[tes:] trainset = [ SubOmniglot(root, [t], num_classes, HOLD_OUT, transform=transform) for t in train ] testset = [ SubOmniglot(root, [v], num_classes, HOLD_OUT, transform=transform) for v in test ] valset = [ SubOmniglot(root, [v], num_classes, HOLD_OUT, transform=transform) for v in val ] self.alphabets = alphabets self.alphabets_train = train self.alphabets_test = test self.alphabets_val = val self.data_train = trainset self.data_test = testset self.data_val = valset
def __init__(self, root, background=True, transform=None, character_target_transform=None, alphabet_target_transform=None, download=False, eval_split_train=True, out_character=True, contrast_training=True): super(Omniglot, self).__init__(join(root, self.folder), transform=transform, target_transform=character_target_transform) self.background = background if download: self.download() if not self._check_integrity(): raise RuntimeError('Dataset not found or corrupted.' + ' You can use download=True to download it') self.character_target_transform = character_target_transform self.alphabet_target_transform = alphabet_target_transform self.target_folder = join(self.root, self._get_target_folder()) self._alphabets = list_dir(self.target_folder) self._characters = sum( [[join(a, c) for c in list_dir(join(self.target_folder, a))] for a in self._alphabets], []) self._character_images = [[ (image, idx, self._alphabets.index(character.split('/')[0])) for image in list_files(join(self.target_folder, character), '.png') ] for idx, character in enumerate(self._characters)] self._flat_character_images = sum(self._character_images, []) self.contrast_training = contrast_training # 20 samples per character self._flat_character_images = np.array( self._flat_character_images).reshape(-1, 20, 3) if eval_split_train: self._flat_character_images = self._flat_character_images[:, :5, :] else: self._flat_character_images = self._flat_character_images[:, 5:, :] self._flat_character_images = self._flat_character_images.reshape( -1, 3) self.out_character = out_character if self.out_character: self.targets = self._flat_character_images[:, 1].astype(np.int64) else: self.targets = self._flat_character_images[:, 2].astype(np.int64)
def __init__(self, root: str, use_frame=True, frames_num=10, split_by='number', normalization='max'): ''' :param root: 保存数据集的根目录 :type root: str :param use_frame: 是否将事件数据转换成帧数据 :type use_frame: bool :param frames_num: 转换后数据的帧数 :type frames_num: int :param split_by: 脉冲数据转换成帧数据的累计方式。``'time'`` 或 ``'number'`` :type split_by: str :param normalization: 归一化方法,为 ``None`` 表示不进行归一化; 为 ``'frequency'`` 则每一帧的数据除以每一帧的累加的原始数据数量; 为 ``'max'`` 则每一帧的数据除以每一帧中数据的最大值; 为 ``norm`` 则每一帧的数据减去每一帧中的均值,然后除以标准差 :type normalization: str or None NavGesture 数据集,出自 `Event-based Visual Gesture Recognition with Background Suppression running on a smart-phone <https://www.neuromorphic-vision.com/public/publications/57/publication.pdf>`_, 数据来源于ATIS相机拍摄的手势。原始数据的原始下载地址参见 https://www.neuromorphic-vision.com/public/downloads/navgesture/。 关于转换成帧数据的细节,参见 :func:`~spikingjelly.datasets.utils.integrate_events_to_frames`。 ''' super().__init__() # depend on loris events_root = os.path.join(root, 'events') if os.path.exists(events_root) and os.listdir(events_root).__len__() == 9: # 如果root目录下存在events_root目录,且events_root下有10个子文件夹,则认为数据集文件存在 print(f'events data root {events_root} already exists.') else: self.download_and_extract(root, events_root) self.file_name = [] # 保存数据文件的路径 self.use_frame = use_frame self.data_dir = None if use_frame: self.normalization = normalization if normalization == 'frequency': dir_suffix = normalization else: dir_suffix = None frames_root = os.path.join(root, f'frames_num_{frames_num}_split_by_{split_by}_normalization_{dir_suffix}') if os.path.exists(frames_root) and os.listdir(frames_root).__len__() == 9: # 如果root目录下存在frames_root目录,且frames_root下有10个子文件夹,则认为数据集文件存在 print(f'frames data root {frames_root} already exists.') else: os.mkdir(frames_root) self.create_frames_dataset(events_root, frames_root, frames_num, split_by, normalization) for sub_dir in utils.list_dir(frames_root, True): self.file_name.extend(utils.list_files(sub_dir, '.npy', True)) self.data_dir = frames_root else: for sub_dir in utils.list_dir(events_root, True): self.file_name.extend(utils.list_files(sub_dir, '.dat', True)) self.data_dir = events_root
def create_frames_dataset(events_data_dir: str, frames_data_dir: str, frames_num: int, split_by: str, normalization: str or None): width, height = ASLDVS.get_wh() thread_list = [] for source_dir in utils.list_dir(events_data_dir): abs_source_dir = os.path.join(events_data_dir, source_dir) abs_target_dir = os.path.join(frames_data_dir, source_dir) if not os.path.exists(abs_target_dir): os.mkdir(abs_target_dir) print(f'mkdir {abs_target_dir}') print(f'thread {thread_list.__len__()} convert events data in {abs_source_dir} to {abs_target_dir}') thread_list.append( FunctionThread(convert_events_dir_to_frames_dir, abs_source_dir, abs_target_dir, '.mat', ASLDVS.read_bin, height, width, frames_num, split_by, normalization, 1, True)) # 文件数量太多,体积太大,因此采用压缩格式 # 这个数据集的文件夹数量24,一次启动24个线程太多,因此一次只启动max_running_threads个线程 max_running_threads = max(multiprocessing.cpu_count(), 8) for i in range(0, thread_list.__len__(), max_running_threads): for j in range(i, min(i + max_running_threads, thread_list.__len__())): thread_list[j].start() print(f'thread {j} start') for j in range(i, min(i + max_running_threads, thread_list.__len__())): print('thread', j, 'join') thread_list[j].join() print('thread', j, 'finished')
def __init__(self, root, train=True, transforms=None, download=False): self.root = join(os.path.expanduser(root), self.folder) # print(f"directorio raiz: {self.root}") self.train = train self.transforms = transforms if download: self.download() self.split = self.load_split() # print("Anotaciones") # print(self.split) self.images_folder = join(self.root, 'Images') # print(f"directorio de imagenes: {self.images_folder}") self.annotations_folder = join(self.root, 'Annotation') # print(f"directorio de anotaciones: {self.annotations_folder}") self._breeds = list_dir(self.images_folder) # print("Tipos de perros:") # print(self._breeds) self._breed_images = [(annotation + '.jpg', idx) for annotation, idx in self.split]
def __init__(self, root, frames_per_clip, step_between_clips=1, frame_rate=None, extensions=('mp4', ), transform=None, cached=None, _precomputed_metadata=None): super(Kinetics400, self).__init__(root) extensions = extensions classes = list(sorted(list_dir(root))) class_to_idx = {classes[i]: i for i in range(len(classes))} self.samples = make_dataset(self.root, class_to_idx, extensions, is_valid_file=None) self.classes = classes video_list = [x[0] for x in self.samples] self.video_clips = VideoClips( video_list, frames_per_clip, step_between_clips, frame_rate, _precomputed_metadata, ) self.transform = transform
def __init__(self, root, train=True, transform=None, target_transform=None, download=False): super(Dogs, self).__init__(root, transform=transform, target_transform=target_transform) self.loader = default_loader self.train = train if download: self.download() split = self.load_split() self.images_folder = join(self.root, 'Images') self.annotations_folder = join(self.root, 'Annotation') self._breeds = list_dir(self.images_folder) self._breed_images = [(annotation + '.jpg', idx) for annotation, idx in split] self._flat_breed_images = self._breed_images
def create_frames_dataset(events_data_dir: str, frames_data_dir: str, frames_num: int, split_by: str, normalization: str or None): width, height = NMNIST.get_wh() thread_list = [] for key in resource.keys(): source_dir = os.path.join(events_data_dir, key) target_dir = os.path.join(frames_data_dir, key) os.mkdir(target_dir) print(f'mkdir {target_dir}') print(f'convert {source_dir} to {target_dir}') for sub_dir in utils.list_dir(source_dir): source_sub_dir = os.path.join(source_dir, sub_dir) target_sub_dir = os.path.join(target_dir, sub_dir) os.mkdir(target_sub_dir) thread_list.append( FunctionThread(convert_events_dir_to_frames_dir, source_sub_dir, target_sub_dir, '.bin', NMNIST.read_bin, height, width, frames_num, split_by, normalization)) thread_list[-1].start() print(f'thread {thread_list.__len__() - 1} start') for i in range(thread_list.__len__()): thread_list[i].join() print(f'thread {i} finished')
def __init__(self, root, frames_per_clip, step_between_clips=1, frame_rate=None, downsample_size=None, spatial_transform=None, temporal_transform=None, target_transform=None): super(VideoDataset, self).__init__(root) extensions = ('',) classes = list(sorted(list_dir(root))) class_to_idx = {classes[i]: i for i in range(len(classes))} self.samples = make_dataset(self.root, class_to_idx, extensions, is_valid_file=None) self.classes = classes self.frames_per_clip = frames_per_clip self.steps = self._init_steps(step_between_clips) self.video_list = [x[0] for x in self.samples] self.video_clips = VideoClips(self.video_list, frames_per_clip, step_between_clips, frame_rate, downsample_size=downsample_size) #self.transform = transform self.spatial_transform = spatial_transform self.temporal_transform = temporal_transform print('Number of {} video clips: {:d} ({:d} images)'.format( root, self.video_clips.num_clips(), self.video_clips.num_total_frames())) print("Number of clips per class: ", self._num_clips_per_class()) print("Number of frames per class: ", self._num_frames_per_class())
def __init__(self, root, annotation_path, frames_per_clip, step_between_clips=1, fold=1, train=True, framewiseTransform=False, transform=None): super(HMDB51, self).__init__(root) if not 1 <= fold <= 3: raise ValueError( "fold should be between 1 and 3, got {}".format(fold)) extensions = ('avi', ) self.fold = fold self.train = train classes = list(sorted(list_dir(root))) class_to_idx = {classes[i]: i for i in range(len(classes))} self.samples = make_dataset(self.root, class_to_idx, extensions, is_valid_file=None) self.classes = classes video_list = [x[0] for x in self.samples] video_clips = VideoClips(video_list, frames_per_clip, step_between_clips) self.indices = self._select_fold(video_list, annotation_path, fold, train) self.video_clips = video_clips.subset(self.indices) self.video_list = [video_list[i] for i in self.indices] self.framewiseTransform = framewiseTransform self.transform = transform
def __init__(self, root, annotation_path, frames_per_clip, step_between_clips=1, frame_rate=None, fold=1, train=True, transform=None, _precomputed_metadata=None, num_workers=1, _video_width=0, _video_height=0, _video_min_dimension=0, _audio_samples=0): super(MYUCF101, self).__init__(root) if not 1 <= fold <= 3: raise ValueError( "fold should be between 1 and 3, got {}".format(fold)) extensions = ('avi', ) self.fold = fold self.train = train classes = list(sorted(list_dir(root))) class_to_idx = {classes[i]: i for i in range(len(classes))} self.samples = make_dataset(self.root, class_to_idx, extensions, is_valid_file=None) self.classes = classes video_list = [x[0] for x in self.samples] video_clips = VideoClips( video_list, frames_per_clip, step_between_clips, frame_rate, _precomputed_metadata, num_workers=num_workers, _video_width=_video_width, _video_height=_video_height, _video_min_dimension=_video_min_dimension, _audio_samples=_audio_samples, ) meta_data_str_ = os.path.join( root, f"meta_data_train_{train}_fold_{fold}_frames_{frames_per_clip}_skip_" f"{step_between_clips}.pickle") if not os.path.exists(meta_data_str_): with open(meta_data_str_, 'wb') as ff: pickle.dump(video_clips.metadata, ff) self.video_clips_metadata = video_clips.metadata self.indices = self._select_fold(video_list, annotation_path, fold, train) self.video_clips = video_clips.subset(self.indices) self.transform = transform
def __init__(self, root, annotation_path, frames_per_clip, step_between_clips=1, frame_rate=None, fold=1, train=True, transform=None, _precomputed_metadata=None, num_workers=1, _video_width=0, _video_height=0, _video_min_dimension=0, _audio_samples=0): super(UCF101, self).__init__(root) if not 1 <= fold <= 3: raise ValueError( "fold should be between 1 and 3, got {}".format(fold)) extensions = ('avi', ) self.fold = fold self.train = train classes = list(sorted(list_dir(root))) class_to_idx = {classes[i]: i for i in range(len(classes))} self.samples = make_dataset(self.root, class_to_idx, extensions, is_valid_file=None) self.classes = classes video_list = [x[0] for x in self.samples] metadata_filepath = os.path.join(root, 'ucf101_metadata.pt') if os.path.exists(metadata_filepath): metadata = torch.load(metadata_filepath) else: metadata = None video_clips = VideoClips( video_list, frames_per_clip, step_between_clips, frame_rate, metadata, num_workers=num_workers, _video_width=_video_width, _video_height=_video_height, _video_min_dimension=_video_min_dimension, _audio_samples=_audio_samples, ) if not os.path.exists(metadata_filepath): torch.save(video_clips.metadata, metadata_filepath) self.video_clips_metadata = video_clips.metadata self.indices = self._select_fold(video_list, annotation_path, fold, train) self.video_clips = video_clips.subset(self.indices) self.transform = transform
def __init__(self, root, extensions=None, clip_length_in_frames=12, frames_between_clips=12, frame_rate=12, transforms = None): # print(root, clip_length_in_frames, frames_between_clips) if extensions == None: extensions = ('avi','mp4') classes = list(sorted(list_dir(root))) class_to_idx = {classes[i]: i for i in range(len(classes))} self.samples = self.make_dataset(root, class_to_idx, extensions, is_valid_file=None) video_list = [x[0] for x in self.samples] self.video_clips = VideoClips(sorted(glob(root+'/**/*')), clip_length_in_frames, frames_between_clips,frame_rate=frame_rate,num_workers=16) self.transforms = transforms
def init_data(self, root, frames_per_clip, step_between_clips=6, frame_rate=6, train=True, transform=None, _precomputed_metadata=None, num_workers=1, _video_width=0, _video_height=0, _video_min_dimension=0, _audio_samples=0): super(HMDB51, self).__init__(root) extensions = ('avi', ) if train: root = root + "/train" else: root = root + "/test" classes = sorted(list_dir(root)) class_to_idx = {class_: i for (i, class_) in enumerate(classes)} print(class_to_idx) self.samples = [] for target_class in sorted(class_to_idx.keys()): class_index = class_to_idx[target_class] target_dir = os.path.join(root, target_class) for root_curr, _, fnames in sorted( os.walk(target_dir, followlinks=True)): for fname in sorted(fnames): path = os.path.join(root_curr, fname) if os.path.isfile(path): item = path, class_index self.samples.append(item) video_paths = [path for (path, _) in self.samples] video_clips = VideoClips( video_paths, frames_per_clip, step_between_clips, frame_rate, _precomputed_metadata, num_workers=num_workers, _video_width=_video_width, _video_height=_video_height, _video_min_dimension=_video_min_dimension, _audio_samples=_audio_samples, ) self.train = train self.classes = classes self.video_clips_metadata = video_clips.metadata self.indices = self.get_indices(video_paths) self.video_clips = video_clips.subset(self.indices) self.transform = transform
def __init__(self, root, setname='images_background', transform=None, target_transform=None, download=False): self.root = join(os.path.expanduser(root), self.folder) self.setname = setname self.transform = transform self.target_transform = target_transform if download: self.download() if not self._check_integrity(): raise RuntimeError('Dataset not found or corrupted.' + ' You can use download=True to download it') self.target_folder = join(self.root, self._get_target_folder()) self._alphabets = list_dir(self.target_folder) self._characters = sum([[join(a, c) for c in list_dir(join(self.target_folder, a))] for a in self._alphabets], []) self._character_images = [[(image, idx) for image in list_files(join(self.target_folder, character), '.png')] for idx, character in enumerate(self._characters)] self._flat_character_images = sum(self._character_images, [])
def download(self): import zipfile import shutil if self._check_integrity(): return for name in self.zips_md5: zip_filename = '{0}.zip'.format(name) filename = os.path.join(self.root, zip_filename) if os.path.isfile(filename): continue url = '{0}/{1}'.format(self.download_url_prefix, zip_filename) download_url(url, self.root, zip_filename, self.zips_md5[name]) with zipfile.ZipFile(filename, 'r') as f: f.extractall(self.root) filename = os.path.join(self.root, self.filename) with h5py.File(filename, 'w') as f: group = f.create_group('omniglot') for name in self.zips_md5: alphabets = list_dir(os.path.join(self.root, name)) characters = [(name, alphabet, character) for alphabet in alphabets for character in list_dir(os.path.join(self.root, name, alphabet))] for _, alphabet, character in characters: filenames = glob.glob(os.path.join(self.root, name, alphabet, character, '*.png')) dataset = group.create_dataset('{0}/{1}'.format(alphabet, character), (len(filenames), 105, 105), dtype='uint8') for i, char_filename in enumerate(filenames): image = Image.open(char_filename, mode='r').convert('L') dataset[i] = ImageOps.invert(image) shutil.rmtree(os.path.join(self.root, name))
def __init__(self, args, root, alpha_ind=None, background=True, selected_chars=None, size=15000): super(Omniglot, self).__init__(root) self.background = background # True for training, False for testing self.args = args self.lines = 500 self.root = root self.target_folder = join(self.root, self.folder, self._get_target_folder()) self._alphabets = list_dir(self.target_folder) if not self.background: self._alphabets = [self._alphabets[alpha_ind]] self._characters = [[c for c in list_dir(join(self.target_folder, a))] for a in self._alphabets] self.text_list = open( os.path.join( self.root, 'gt', 'train/train_regular+bold+light+italic_50_resample.txt') ).readlines() self.txts = self.extract_txt() self.color_jitter = transforms.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.3, hue=0.2) self.ToPIL = transforms.ToPILImage() self.bg_im = ImagePatch(join(self.root, 'ims')) self.char_aug_threshold = 0.5 self.len = size self.alpha_ind = alpha_ind
def __init__(self, root, train=True): self.root = root self.loader = default_loader self.train = train split = self.load_split() self.images_folder = join(self.root, 'Images') self.annotations_folder = join(self.root, 'Annotation') self._breeds = list_dir(self.images_folder) self._breed_images = [(annotation + '.jpg', idx) for annotation, idx in split] self._flat_breed_images = self._breed_images
def from_ds_folder(cls, dataset_root, metadata_path=None, extract_groom=False, **kwargs): # make dataset classes = list(sorted(list_dir(dataset_root))) class_to_idx = {classes[i]: i for i in range(len(classes))} items = make_dataset(dataset_root, class_to_idx, extensions=(".mp4", )) logger.info('class2idx: %s', class_to_idx) samples = [s[0] for s in items] labels = [s[1] for s in items] metadata = None if metadata_path is not None and os.path.exists(metadata_path): metadata = torch.load(metadata_path) metadata = VideoClips( samples, # for computing timestamps _precomputed_metadata=metadata, num_workers=8, ).metadata if metadata_path is not None and metadata is None: torch.save(metadata, metadata_path) if extract_groom: # special case: groom under dataset_root/groom groom_folder = f'{dataset_root}/groom' annots = read_annotations(groom_folder) extracted_metadata, extracted_labels = extract_metadata_from_annotations( metadata, annots) # extracted_paths = set(item['video_paths'] for item in extracted_metadata) extracted_labels = [class_to_idx[a] for a in extracted_labels] logger.info('Extracted groom video count: %s', len(extracted_labels)) for vid_path, vid_pts, vid_fps, lab in zip(metadata['video_paths'], metadata['video_pts'], metadata['video_fps'], labels): if 'not_groom' not in vid_path: continue extracted_metadata['video_paths'].append(vid_path) extracted_metadata['video_pts'].append(vid_pts) extracted_metadata['video_fps'].append(vid_fps) extracted_labels.append(lab) metadata, labels = extracted_metadata, extracted_labels return cls(metadata=metadata, labels=labels, dataset_root=dataset_root, **kwargs)
def create_frames_dataset(events_data_dir, frames_data_dir, frames_num=10, split_by='time', normalization=None): width, height = NAVGesture.get_wh() thread_list = [] for source_dir in utils.list_dir(events_data_dir): abs_source_dir = os.path.join(events_data_dir, source_dir) abs_target_dir = os.path.join(frames_data_dir, source_dir) if not os.path.exists(abs_target_dir): os.mkdir(abs_target_dir) print(f'mkdir {abs_target_dir}') print(f'thread {thread_list.__len__()} convert events data in {abs_source_dir} to {abs_target_dir}') thread_list.append(FunctionThread(convert_events_dir_to_frames_dir, abs_source_dir, abs_target_dir, '.dat', NAVGesture.read_bin, height, width, frames_num, split_by, normalization)) thread_list[-1].start() for i in range(thread_list.__len__()): thread_list[i].join() print('thread', i, 'finished')
def __init__(self, root, frames_per_clip, step_between_clips=1, frame_rate=None, extensions=('avi', ), transform=None, num_workers=1, _video_width=0, _video_height=0, _video_min_dimension=0, _audio_samples=0): super(Kinetics400, self).__init__(root) classes = list(sorted(list_dir(root))) class_to_idx = {classes[i]: i for i in range(len(classes))} self.samples = make_dataset(self.root, class_to_idx, extensions, is_valid_file=None) self.classes = classes video_list = [x[0] for x in self.samples] split = root.split('/')[-1].strip('/') metadata_filepath = os.path.join( root, 'kinetics_metadata_{}.pt'.format(split)) if os.path.exists(metadata_filepath): metadata = torch.load(metadata_filepath) else: metadata = None self.video_clips = VideoClips( video_list, frames_per_clip, step_between_clips, frame_rate, metadata, num_workers=num_workers, _video_width=_video_width, _video_height=_video_height, _video_min_dimension=_video_min_dimension, _audio_samples=_audio_samples, ) self.transform = transform if not os.path.exists(metadata_filepath): torch.save(self.video_clips.metadata, metadata_filepath)
def __init__(self, root, frames_per_clip, step_between_clips=1, frame_rate=None, spatial_transform=None, temporal_transform=None): super(VideoDataset, self).__init__(root) extensions = ('',) classes = list(sorted(list_dir(root))) class_to_idx = {classes[i]: i for i in range(len(classes))} self.samples = make_dataset(self.root, class_to_idx, extensions, is_valid_file=None) self.classes = classes video_list = [x[0] for x in self.samples] self.video_clips = VideoClips(video_list, frames_per_clip, step_between_clips, frame_rate) print('Number of {} video clips: {:d}'.format(root, self.video_clips.num_clips())) #self.transform = transform self.spatial_transform = spatial_transform self.temporal_transform = temporal_transform
def __init__(self, root, frames_per_clip, step_between_clips=1, frame_rate=None, extensions=("mp4", ), transform=None, cached=None, _precomputed_metadata=None, sp_method=None, num_components=None, prob=None, randomise_superpixels=None, randomise_superpixels_range=None): super(Kinetics400, self).__init__(root) extensions = extensions classes = list(sorted(list_dir(root))) class_to_idx = {classes[i]: i for i in range(len(classes))} self.samples = make_dataset(self.root, class_to_idx, extensions, is_valid_file=None) self.classes = classes video_list = [x[0] for x in self.samples] self.video_list = video_list self.video_clips = VideoClips( video_list, frames_per_clip, step_between_clips, frame_rate, _precomputed_metadata, ) self.transform = transform self.sp_method = sp_method self.num_components = num_components self.prob = prob self.randomise_superpixels = randomise_superpixels self.randomise_superpixels_range = randomise_superpixels_range
def __init__(self, root, frames_per_clip, step_between_clips=1, frame_rate=None, downsample=None, spatial_transform=None, temporal_transform=None, opt_flow_preprocess=False): super(I3DDataset, self).__init__(root) extensions = ('', ) classes = list(sorted(list_dir(root))) class_to_idx = {classes[i]: i for i in range(len(classes))} if opt_flow_preprocess: self.preprocess(extensions[0]) self.samples = make_dataset(self.root, class_to_idx, extensions, is_valid_file=None) self.classes = classes # TODO: use video_utils subset self.optflow_list = [os.path.join(x, 'flow') for x in self.video_list] self.video_clips = VideoClips(self.video_list, frames_per_clip, step_between_clips, frame_rate, downsample_size=downsample) self.optflow_clips = VideoClips(self.optflow_list, frames_per_clip, step_between_clips, frame_rate) self.spatial_transform = spatial_transform self.temporal_transform = temporal_transform if opt_flow_preprocess: self.preprocess(extensions[0])
def __init__(self, root, train=True, transform=None, download=False, with_id=False): self.root = join(os.path.expanduser(root), self.folder) self.train = train self.transform = transform self.with_id = with_id if download: self.download() split = self.load_split() self.images_folder = join(self.root, 'Images') self.annotations_folder = join(self.root, 'Annotation') self._breeds = list_dir(self.images_folder) self._breed_annotations = [[ (annotation, box, size, idx) for box, size in self.get_boxes( join(self.annotations_folder, annotation)) ] for annotation, idx in split] self._flat_breed_annotations = sum(self._breed_annotations, []) if with_id: self._flat_breed_images = [ (annotation + '.jpg', annotation, idx) for annotation, box, size, idx in self._flat_breed_annotations ] else: self._flat_breed_images = [ (annotation + '.jpg', idx) for annotation, box, size, idx in self._flat_breed_annotations ] self.classes = self.get_classes()
def __init__(self, feat_path, root, annotation_path, frames_per_clip, extracted_frames_per_clip=2, step_between_clips=1, fold=1, train=True, transform=None): super(HMDB51FeatureSequenceDataset, self).__init__(root) if not 1 <= fold <= 3: raise ValueError( "fold should be between 1 and 3, got {}".format(fold)) extensions = ('avi', ) self.fold = fold self.train = train self.frames_per_clip = frames_per_clip self.extracted_frames_per_clip = extracted_frames_per_clip self.step_between_clips = step_between_clips with open(feat_path, "rb") as fp: self.features = pickle.load(fp) classes = list(sorted(list_dir(root))) class_to_idx = {classes[i]: i for i in range(len(classes))} self.samples = make_dataset(self.root, class_to_idx, extensions, is_valid_file=None) self.classes = classes video_list = [x[0] for x in self.samples] video_clips = VideoClips(video_list, frames_per_clip, step_between_clips) self.indices = self._select_fold(video_list, annotation_path, fold, train) self.video_clips = video_clips.subset(self.indices) self.video_list = [video_list[i] for i in self.indices] self.transform = transform
def __init__(self, split, root, cropped=False, transform=None, target_transform=None, verbose=False): # self.root = path.join(path.expanduser(root), self.folder) self.root = root self.cropped = cropped self.transform = transform self.target_transform = target_transform self.verbose = verbose self.classes = classes self.images_folder = path.join(self.root, 'Images') self.annotation_folder = path.join(self.root, 'Annotation') self._dog_breeds = list_dir(self.images_folder) if self.cropped: self._breed_annotations = [[ (annotation, bounding_box, index) for bounding_box in self.get_bounding_boxes( path.join(self.annotation_folder, annotation)) ] for annotation, index in split] self._flat_breed_annotations = sum(self._breed_annotations, []) self._flat_breed_images = [ (annotation + '.jpg', index) for annotation, _, index in self._flat_breed_annotations ] else: self._breed_images = [(annotation + '.jpg', index) for annotation, index in split] self._flat_breed_images = self._breed_images
def __init__(self, root, frames_per_clip, step_between_clips=1, frame_rate=None, extensions=("mp4", ), transform=None, _precomputed_metadata=None, num_workers=1, _video_width=0, _video_height=0, _video_min_dimension=0, _audio_samples=0, _audio_channels=0): super(Mice, self).__init__(root) classes = list(sorted(list_dir(root))) class_to_idx = {classes[i]: i for i in range(len(classes))} self.samples = make_dataset(self.root, class_to_idx, extensions, is_valid_file=None) self.classes = classes video_list = [x[0] for x in self.samples] self.video_clips = VideoClips( video_list, frames_per_clip, step_between_clips, frame_rate, _precomputed_metadata, num_workers=num_workers, _video_width=_video_width, _video_height=_video_height, _video_min_dimension=_video_min_dimension, _audio_samples=_audio_samples, _audio_channels=_audio_channels, ) self.transform = transform