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
