def set_df_list(self, train):
dataset = DatasetDcase2019Task4(cfg.workspace,
base_feature_dir=os.path.join(cfg.workspace, "dataset", "features"),
save_log_feature=False)
transforms = get_transforms(cfg.max_frames)
weak_df = dataset.initialize_and_get_df(cfg.weak)
load_weak = DataLoadDf(weak_df, dataset.get_feature_file, None, transform=transforms)
if train ==True:
self.list_dataset = [load_weak]
else:
synthetic_df = dataset.initialize_and_get_df(cfg.synthetic, download=False)
synthetic_df.onset = synthetic_df.onset * cfg.sample_rate // cfg.hop_length
synthetic_df.offset = synthetic_df.offset * cfg.sample_rate // cfg.hop_length
validation_df = dataset.initialize_and_get_df(cfg.validation)
validation_df.onset = validation_df.onset * cfg.sample_rate // cfg.hop_length
validation_df.offset = validation_df.offset * cfg.sample_rate // cfg.hop_length
eval_desed_df = dataset.initialize_and_get_df(cfg.eval_desed)
eval_desed_df.onset = eval_desed_df.onset * cfg.sample_rate // cfg.hop_length
eval_desed_df.offset = eval_desed_df.offset * cfg.sample_rate // cfg.hop_length
# many_hot_encoder = ManyHotEncoder(classes, n_frames=cfg.max_frames // pooling_time_ratio)
load_synthetic = DataLoadDf(synthetic_df, dataset.get_feature_file, None, transform=transforms)
load_validation = DataLoadDf(validation_df, dataset.get_feature_file, None, transform=transforms)
load_eval_desed = DataLoadDf(eval_desed_df, dataset.get_feature_file, None, transform=transforms)
self.list_dataset = [load_weak, load_synthetic, load_validation, load_eval_desed]
scaler = Scaler()
scaler.calculate_scaler(ConcatDataset(self.list_dataset))
transforms = get_transforms(cfg.max_frames, scaler)
for i in range(len(self.list_dataset)):
self.list_dataset[i].set_transform(transforms)
print(self.list_dataset)
# Datasets
trans_fr = [ApplyLog(), ToTensor(), Unsqueeze(0)]
train_weak_df_fr = dfs["train"]
train_weak_dl_fr = DataLoadDf(train_weak_df_fr, encode_function_label, transform=Compose(trans_fr))
if type_positive != "label" or type_negative != "label":
unlabel_df_fr = dataset.get_df_feat_dir(cfg.unlabel, subpart_data=subpart_data, frames_in_sec=frames_in_sec)
unlabel_dl_fr = DataLoadDf(unlabel_df_fr, encode_function_label, transform=Compose(trans_fr))
datasets_mean = [train_weak_dl_fr, unlabel_dl_fr]
else:
datasets_mean = [train_weak_dl_fr]
# Normalize
if resume_training is None:
scaler = ScalerSum()
scaler.calculate_scaler(ConcatDataset(datasets_mean))
else:
scaler = ScalerSum.load_state_dict(state["scaler"])
LOG.debug(scaler.mean_)
trans_fr_scale = trans_fr + [Normalize(scaler)]
if segment:
trans_fr_scale.append(Unsqueeze(0))
for dl in datasets_mean:
dl.set_transform(Compose(trans_fr_scale))
print(dl.transform)
concat_frames = ConcatDataset(datasets_mean)
trans_fr_sc_embed = deepcopy(trans_fr_scale)
if not segment:
pooling_time_ratio)
encod_func = many_hot_encoder.encode_strong_df
# Normalisation per audio or on the full dataset
if cfg.scaler_type == "dataset":
transforms = get_transforms(cfg.max_frames,
add_axis_conv=add_axis_conv)
weak_data = DataLoadDf(dfs["weak"], encod_func, transforms)
unlabel_data = DataLoadDf(dfs["unlabel"], encod_func, transforms)
train_synth_data = DataLoadDf(dfs["train_synthetic"], encod_func,
transforms)
scaler_args = []
scaler = Scaler()
# # Only on real data since that's our final goal and test data are real
scaler.calculate_scaler(
ConcatDataset([weak_data, unlabel_data, train_synth_data]))
logger.debug(f"scaler mean: {scaler.mean_}")
else:
scaler_args = ["global", "min-max"]
scaler = ScalerPerAudio(*scaler_args)
transforms = get_transforms(cfg.max_frames,
scaler,
add_axis_conv,
noise_dict_params={"snr": cfg.noise_snr})
transforms_valid = get_transforms(cfg.max_frames, scaler, add_axis_conv)
weak_data = DataLoadDf(dfs["weak"],
encod_func,
transforms,
in_memory=cfg.in_memory)
# Put train_synth in frames so many_hot_encoder can work.
# Not doing it for valid, because not using labels (when prediction) and event based metric expect sec.
train_synth_df_frames = train_synth_df.copy()
train_synth_df_frames.onset = train_synth_df_frames.onset * cfg.sample_rate // cfg.hop_length // pooling_time_ratio
train_synth_df_frames.offset = train_synth_df_frames.offset * cfg.sample_rate // cfg.hop_length // pooling_time_ratio
LOG.debug(valid_synth_df.event_label.value_counts())
LOG.debug(valid_synth_df)
train_synth_data = DataLoadDf(train_synth_df_frames,
dataset.get_feature_file,
many_hot_encoder.encode_strong_df,
transform=transforms)
if not no_weak:
list_datasets = [train_weak_data, train_synth_data]
training_data = ConcatDataset(list_datasets)
else:
list_datasets = [train_synth_data]
training_data = train_synth_data
scaler = Scaler()
scaler.calculate_scaler(training_data)
LOG.debug(scaler.mean_)
transforms_valid = get_transforms(cfg.max_frames, scaler=scaler)
# Validation dataset is only used to get an idea of wha could be results on evaluation dataset
validation_dataset = DataLoadDf(validation_df,
dataset.get_feature_file,
many_hot_encoder.encode_strong_df,
transform=transforms_valid)
dataset.get_feature_file,
many_hot_encoder.encode_weak,
transform=transforms)
list_dataset = [train_data]
batch_sizes = [cfg.batch_size]
# batch_sizes = [cfg.batch_size // len(list_dataset)] * len(list_dataset)
weak_mask = slice(cfg.batch_size)
strong_mask = None
scaler = Scaler()
if path.exists(cfg.scaler_fn):
LOG.info('Loading scaler from {}'.format(cfg.scaler_fn))
scaler.load(cfg.scaler_fn)
else:
scaler.calculate_scaler(ConcatDataset(list_dataset))
LOG.info('Saving scaler to {}'.format(cfg.scaler_fn))
scaler.save(cfg.scaler_fn)
LOG.debug(scaler.mean_)
transforms = get_transforms(cfg.max_frames, scaler, augment_type="noise")
transforms_valid = get_transforms(cfg.max_frames, scaler=scaler)
for i in range(len(list_dataset)):
list_dataset[i].set_transform(transforms)
validation_data.set_transform(transforms_valid)
test_data.set_transform(transforms_valid)
concat_dataset = ConcatDataset(list_dataset)
sampler = MultiStreamBatchSampler(concat_dataset, batch_sizes=batch_sizes)
training_data = DataLoader(concat_dataset, batch_sampler=sampler)