def prepare_wav(wav_loc, hparams=None):
""" load wav and convert to correct format
"""
# get rate and date
rate, data = load_wav(wav_loc)
# convert data if needed
if np.issubdtype(type(data[0]), np.integer):
data = int16_to_float32(data)
# bandpass filter
if hparams is not None:
data = butter_bandpass_filter(data,
hparams.butter_lowcut,
hparams.butter_highcut,
rate,
order=5)
# reduce noise
if hparams.reduce_noise:
data = nr.reduce_noise(audio_clip=data,
noise_clip=data,
**hparams.noise_reduce_kwargs)
return rate, data
def get_element(datafile,
indv=None,
element_number=1,
element="syllable",
hparams=None):
# if an individual isnt specified, grab the first one
if indv == None:
indv = datafile.indvs[0]
# get the element
element = datafile.data["indvs"][indv][element]
# get the part of the wav we want to load
st = element["start_times"][element_number]
et = element["end_times"][element_number]
# load the data
rate, element = load_wav(datafile.data["wav_loc"],
offset=st,
duration=et - st,
sr=None)
if np.issubdtype(type(element[0]), np.integer):
element = int16_to_float32(data)
if hparams is not None:
element = butter_bandpass_filter(element,
hparams.butter_lowcut,
hparams.butter_highcut,
rate,
order=5)
return rate, element
def prepare_wav(wav_loc, hparams, debug):
""" load wav and convert to correct format
"""
if debug:
debug_data = {}
else:
debug_data = None
# get rate and date
data, _ = librosa.load(wav_loc, sr=hparams.sr)
# convert data if needed
if np.issubdtype(type(data[0]), np.integer):
data = int16_to_float32(data)
# Chunks to avoid memory issues
len_chunk_minutes = 10
len_chunk_sample = hparams.sr * 60 * len_chunk_minutes
data_chunks = []
for t in range(0, len(data), len_chunk_sample):
start = t
end = min(len(data), t + len_chunk_sample)
data_chunks.append(data[start:end])
# only keep one chunk for debug
if debug:
break
# bandpass filter
data_cleaned = []
if hparams is not None:
for data in data_chunks:
if debug:
debug_data['x'] = data
data = butter_bandpass_filter(data,
hparams.butter_lowcut,
hparams.butter_highcut,
hparams.sr,
order=5)
if debug:
debug_data['x_filtered'] = data
# reduce noise
if hparams.reduce_noise:
data = nr.reduce_noise(audio_clip=data,
noise_clip=data,
**hparams.noise_reduce_kwargs)
if debug:
debug_data['x_rn'] = data
data_cleaned.append(data)
else:
data_cleaned = data_chunks
# concatenate chunks
data = np.concatenate(data_cleaned)
return data, debug_data
def subset_syllables(json_dict,
indv,
unit="syllables",
hparams=None,
include_labels=True):
""" Grab syllables from wav data
"""
if type(indv) == list:
indv = indv[0]
if type(json_dict) != OrderedDict:
json_dict = read_json(json_dict)
# get unit info
start_times = json_dict["indvs"][indv][unit]["start_times"]
# stop times vs end_times is a quick fix that should be fixed on the parsing side
if "end_times" in json_dict["indvs"][indv][unit].keys():
end_times = json_dict["indvs"][indv][unit]["end_times"]
else:
end_times = json_dict["indvs"][indv][unit]["stop_times"]
if include_labels:
labels = json_dict["indvs"][indv][unit]["labels"]
else:
labels = None
# get rate and date
rate, data = load_wav(json_dict["wav_loc"])
# convert data if needed
if np.issubdtype(type(data[0]), np.integer):
data = int16_to_float32(data)
# bandpass filter
if hparams is not None:
data = butter_bandpass_filter(data,
hparams.butter_lowcut,
hparams.butter_highcut,
rate,
order=5)
# reduce noise
if hparams.reduce_noise:
data = nr.reduce_noise(audio_clip=data,
noise_clip=data,
**hparams.noise_reduce_kwargs)
syllables = [
data[int(st * rate):int(et * rate)]
for st, et in zip(start_times, end_times)
]
return syllables, rate, labels
def segment_spec_custom(key, df, DT_ID, save=False, plot=False):
# load wav
rate, data = load_wav(df.data["wav_loc"])
# filter data
data = butter_bandpass_filter(data, butter_min, butter_max, rate)
# segment
# results = dynamic_threshold_segmentation(
# data,
# rate,
# n_fft=n_fft,
# hop_length_ms=hop_length_ms,
# win_length_ms=win_length_ms,
# min_level_db_floor=min_level_db_floor,
# db_delta=db_delta,
# ref_level_db=ref_level_db,
# pre=pre,
# min_silence_for_spec=min_silence_for_spec,
# max_vocal_for_spec=max_vocal_for_spec,
# min_level_db=min_level_db,
# silence_threshold=silence_threshold,
# verbose=True,
# min_syllable_length_s=min_syllable_length_s,
# spectral_range=spectral_range,
# )
results = dynamic_threshold_segmentation(data,
hparams,
verbose=True,
min_syllable_length_s=min_syllable_length_s,
spectral_range=spectral_range)
if results is None:
return
if plot:
plot_segmentations(
results["spec"],
results["vocal_envelope"],
results["onsets"],
results["offsets"],
hop_length_ms,
rate,
figsize=(15, 3)
)
plt.show()
# save the results
json_out = DATA_DIR / "processed" / (DATASET_ID + "_segmented") / DT_ID / "JSON" / (
key + ".JSON"
)
json_dict = df.data.copy()
json_dict["indvs"][list(df.data["indvs"].keys())[0]]["syllables"] = {
"start_times": list(results["onsets"]),
"end_times": list(results["offsets"]),
}
json_txt = json.dumps(json_dict, cls=NoIndentEncoder, indent=2)
# save json
if save:
ensure_dir(json_out.as_posix())
with open(json_out.as_posix(), "w") as json_file:
json.dump(json_dict, json_file, cls=NoIndentEncoder, indent=2)
json_file.close()
# print(json_txt, file=open(json_out.as_posix(), "w"))
#print(json_txt)
return results
dataset.sample_json
rate, data = load_wav(dataset.sample_json["wav_loc"])
mypath = r'I:\avgn_paper-vizmerge\data\processed\bengalese_finch_sakata\2020-04-29_21-12-51\WAV'
# file_current = 'br81bl41_0016.wav'
file_current = 'br82bl42_0016.wav'
file_current = 'tutor_bl5w5_0017.WAV'
rate, data_loaded = load_wav(mypath+'\\'+file_current)
data = data_loaded
times = np.linspace(0,len(data)/rate,len(data));
# filter data
data = butter_bandpass_filter(data, butter_min, butter_max, rate)
plt.plot(times,data)
hparams.ref_level_db = 90
spec_orig = spectrogram(data,
rate,
hparams)
plot_spec(
norm(spec_orig),
fig=None,
ax=None,
rate=None,
hop_len_ms=None,
cmap=plt.cm.afmhot,
show_cbar=True,
def segment_spec_custom(key, df, save=False, plot=False):
processed_files.append(key)
# load wav
data, _ = librosa.load(df.data["wav_loc"], sr=sr)
# filter data
data = butter_bandpass_filter(data, butter_lowcut, butter_highcut, sr)
# segment
results = dynamic_threshold_segmentation(
vocalization=data,
rate=sr,
n_fft=n_fft,
hop_length=ms_to_sample(hop_length_ms, sr),
win_length=ms_to_sample(win_length_ms, sr),
min_level_db_floor=min_level_db_floor,
db_delta=db_delta,
ref_level_db=ref_level_db,
pre=pre,
min_silence_for_spec=min_silence_for_spec,
max_vocal_for_spec=max_vocal_for_spec,
silence_threshold=silence_threshold,
min_syllable_length_s=min_syllable_length_s,
spectral_range=spectral_range,
verbose=True,
)
if results is None:
print('skipping')
return
segmented_files.append(key)
# save the results
json_out = DATA_DIR / "processed" / (
DATASET_ID + "_segmented") / DT_ID / "JSON" / (key + ".JSON")
json_dict = df.data.copy()
json_dict["indvs"][list(df.data["indvs"].keys())[0]]["syllables"] = {
"start_times": NoIndent(list(results["onsets"])),
"end_times": NoIndent(list(results["offsets"])),
}
json_txt = json.dumps(json_dict, cls=NoIndentEncoder, indent=2)
# save json
if save:
ensure_dir(json_out.as_posix())
print(json_txt, file=open(json_out.as_posix(), "w"))
##########################################
##########################################
# Debug: print start/end times in a text file
# marker_path = re.sub('.wav', '.txt', df.data["wav_loc"])
# with open(marker_path, 'w') as ff:
# for onset, offset in zip(results["onsets"], results["offsets"]):
# ff.write(f"{onset}\t{offset}\n")
##########################################
##########################################
return results
def process_bird_wav(
bird,
wav_info,
wav_time,
params,
save_to_folder,
visualize=False,
skip_created=False,
seconds_timeout=300,
save_spectrograms=True,
verbose=False,
):
"""splits a wav file into periods of silence and periods of sound based on params
"""
# Load up the WAV
rate, data = load_wav(wav_info)
params["sample_rate"] = rate
if rate is None or data is None:
return
# bandpass filter
data = butter_bandpass_filter(data.astype("float32"),
params["lowcut"],
params["highcut"],
rate,
order=2)
data = float32_to_int16(data)
# we only want one channel
if len(np.shape(data)) == 2:
data = data[:, 0]
# threshold the (root mean squared of the) audio
rms_data, sound_threshed = RMS(
data,
rate,
params["rms_stride"],
params["rms_window"],
params["rms_padding"],
params["noise_thresh"],
)
# Find the onsets/offsets of sound
onset_sounds, offset_sounds = detect_onsets_offsets(
np.repeat(sound_threshed, int(params["rms_stride"] * rate)),
threshold=0,
min_distance=0,
)
# make sure all onset sounds are at least zero (due to downsampling in RMS)
onset_sounds[onset_sounds < 0] = 0
# threshold clips of sound
for onset_sound, offset_sound in zip(onset_sounds, offset_sounds):
# segment the clip
clip = data[onset_sound:offset_sound]
### if the clip is thresholded, as noise, do not save it into dataset
# bin width in Hz of spectrogram
freq_step_size_Hz = (rate / 2) / params["num_freq"]
bout_spec = threshold_clip(clip,
rate,
freq_step_size_Hz,
params,
visualize=visualize,
verbose=verbose)
if bout_spec is None:
# visualize spectrogram if desired
if visualize:
# compute spectrogram of clip
wav_spectrogram = spectrogram(int16_to_float32(clip), params)
visualize_spec(wav_spectrogram, show=True)
continue
# determine the datetime of this clip
start_time = wav_time + timedelta(seconds=onset_sound / float(rate))
time_string = start_time.strftime("%Y-%m-%d_%H-%M-%S-%f")
# create a subfolder for the individual bird if it doesn't already exist
bird_folder = Path(save_to_folder).resolve() / bird
ensure_dir(bird_folder)
# save data
save_bout_wav(data, rate, bird_folder, bird, wav_info, time_string,
skip_created)
# save the spectrogram of the data
if save_spectrograms:
save_bout_spec(bird_folder, bout_spec, time_string, skip_created)
