def run_results_on_signal(tensor_spectrogram,
reference_segments,
bars,
plotting=True):
"""
Compute all desired results on the signal (precision, recall and f measure).
The window_length is set to 0.5 seconds.
Parameters
----------
tensor_spectrogram : tensorly tensor
The tensor_spectrogram of the song.
references_segments : list of tuples
The segments from the annotations.
bars : list of tuple of float
The bars of the song.
plotting : boolean, optional
A boolean whether to plot the autosimilarity with the segmentation or not.
The default is True.
Returns
-------
all_res : nested list
Scores of all computation.
"""
unfolded = tl.unfold(tensor_spectrogram, 2)
if plotting:
plot_spec_with_annotations_abs_ord(
as_seg.get_autosimilarity(unfolded, transpose=True,
normalize=True),
dm.frontiers_from_time_to_bar(
dm.segments_to_frontiers(reference_segments), bars),
cmap=cm.Greys)
return compute_all_results(unfolded,
reference_segments,
bars,
window_length=0.5), compute_all_results(
unfolded,
reference_segments,
bars,
window_length=3)
def cross_validation_on_signal(learning_dataset,
testing_dataset,
penalty_range,
annotations_type="MIREX10",
subdivision=96,
penalty_func="modulo8",
convolution_type="eight_bands"):
"""
Segmentation results when segmenting directly the signal, where the penalty_weight is fitted by cross-validation.
"""
annotations_folder = "{}\\{}".format(annotations_folder_path,
annotations_type)
hop_length = 32
hop_length_seconds = 32 / 44100
learning_dataset_paths = scr.load_RWC_dataset(learning_dataset,
annotations_type)
zero_five = []
three = []
for song_and_annotations in learning_dataset_paths:
#printmd('**Chanson courante: {}**'.format(song_and_annotations[0]))
this_song = []
this_song_three = []
song_number = song_and_annotations[0].replace(".wav", "")
annot_path = "{}\\{}".format(annotations_folder,
song_and_annotations[1])
annotations = dm.get_segmentation_from_txt(annot_path,
annotations_type)
references_segments = np.array(annotations)[:, 0:2]
bars, spectrogram = scr.load_or_save_spectrogram_and_bars(
persisted_path, "{}\\{}".format(learning_dataset, song_number),
"pcp", hop_length)
tensor_spectrogram = tf.tensorize_barwise(spectrogram, bars,
hop_length_seconds,
subdivision)
unfolded = tl.unfold(tensor_spectrogram, 2)
autosimilarity = as_seg.get_autosimilarity(unfolded,
transpose=True,
normalize=True)
for param in penalty_range:
segments = as_seg.dynamic_convolution_computation(
autosimilarity,
mix=1,
penalty_weight=param,
penalty_func=penalty_func,
convolution_type=convolution_type)[
0] #, fixed_ponderation = fixed_ponderation
segments_in_time = dm.segments_from_bar_to_time(segments, bars)
tp, fp, fn = dm.compute_rates_of_segmentation(references_segments,
segments_in_time,
window_length=0.5)
prec, rap, f_mes = dm.compute_score_of_segmentation(
references_segments, segments_in_time, window_length=0.5)
this_song.append(
[tp, fp, fn,
round(prec, 4),
round(rap, 4),
round(f_mes, 4)])
tp, fp, fn = dm.compute_rates_of_segmentation(references_segments,
segments_in_time,
window_length=3)
prec, rap, f_mes = dm.compute_score_of_segmentation(
references_segments, segments_in_time, window_length=3)
this_song_three.append(
[tp, fp, fn,
round(prec, 4),
round(rap, 4),
round(f_mes, 4)])
zero_five.append(this_song)
three.append(this_song_three)
fmes_param_means = []
for idx_param in range(len(penalty_range)):
fmes_param_means.append(np.mean(np.array(zero_five)[:, idx_param, 5]))
idx_current_best_param = np.argmax(fmes_param_means)
best_param = penalty_range[idx_current_best_param]
display(
pd.DataFrame(np.array([best_param]),
index=['Best lambda: ponderation parameter.'],
columns=["Learned parameter."]).T)
final_res_sig_zero_five, final_res_sig_three = fixed_conditions_signal(
testing_dataset,
best_param,
annotations_type=annotations_type,
subdivision=subdivision,
penalty_func=penalty_func,
legend=", on test dataset.",
convolution_type=convolution_type)
return final_res_sig_zero_five, final_res_sig_three
def oracle_ranks(dataset,
ranks_rhythm,
ranks_pattern,
penalty_weight,
annotations_type="MIREX10",
subdivision=96,
penalty_func="modulo8",
convolution_type="eight_bands"):
"""
Segmentation results in the oracle condition,
where the rank resulting in the best f measure is chosen (among a range) for each song.
Results are computed with a fixed penalty weight.
"""
annotations_folder = "{}\\{}".format(annotations_folder_path,
annotations_type)
hop_length = 32
hop_length_seconds = 32 / 44100
paths = scr.load_RWC_dataset(dataset, annotations_type)
zero_five = []
three = []
for song_and_annotations in paths:
#printmd('**Chanson courante: {}**'.format(song_and_annotations[0]))
zero_five_rank = []
three_rank = []
song_number = song_and_annotations[0].replace(".wav", "")
annot_path = "{}\\{}".format(annotations_folder,
song_and_annotations[1])
annotations = dm.get_segmentation_from_txt(annot_path,
annotations_type)
references_segments = np.array(annotations)[:, 0:2]
bars, spectrogram = scr.load_or_save_spectrogram_and_bars(
persisted_path, "{}\\{}".format(dataset, song_number), "pcp",
hop_length)
tensor_spectrogram = tf.tensorize_barwise(spectrogram, bars,
hop_length_seconds,
subdivision)
for rank_pattern in ranks_pattern:
for i, rank_rhythm in enumerate(ranks_rhythm):
ranks = [12, rank_rhythm, rank_pattern]
persisted_arguments = "_{}_{}_{}_{}".format(
song_number, "pcp", "chromas", subdivision)
q_factor = scr.NTD_decomp_as_script(persisted_path,
persisted_arguments,
tensor_spectrogram,
ranks,
init="chromas")[1][2]
autosimilarity = as_seg.get_autosimilarity(q_factor,
transpose=True,
normalize=True)
segments = as_seg.dynamic_convolution_computation(
autosimilarity,
mix=1,
penalty_weight=penalty_weight,
penalty_func=penalty_func,
convolution_type=convolution_type)[0]
segments_in_time = dm.segments_from_bar_to_time(segments, bars)
tp, fp, fn = dm.compute_rates_of_segmentation(
references_segments, segments_in_time, window_length=0.5)
prec, rap, f_mes = dm.compute_score_of_segmentation(
references_segments, segments_in_time, window_length=0.5)
zero_five_rank.append([
tp, fp, fn,
round(prec, 4),
round(rap, 4),
round(f_mes, 4)
])
tp, fp, fn = dm.compute_rates_of_segmentation(
references_segments, segments_in_time, window_length=3)
prec, rap, f_mes = dm.compute_score_of_segmentation(
references_segments, segments_in_time, window_length=3)
three_rank.append([
tp, fp, fn,
round(prec, 4),
round(rap, 4),
round(f_mes, 4)
])
zero_five.append(zero_five_rank)
three.append(three_rank)
zero_five_array = np.array(zero_five)
three_array = np.array(three)
scores_oracle_NTD_zero_five = []
scores_oracle_NTD_three = []
for song in range(len(zero_five)):
all_f_zero_five = zero_five_array[song, :, 5]
this_song_best_couple_idx_zero_five = np.argmax(all_f_zero_five)
scores_oracle_NTD_zero_five.append(
zero_five_array[song, this_song_best_couple_idx_zero_five, :])
all_f_three = three_array[song, :, 5]
this_song_best_couple_idx_three = np.argmax(all_f_three)
scores_oracle_NTD_three.append(
three_array[song, this_song_best_couple_idx_three, :])
final_scores_zero_five = [
np.mean(np.array(scores_oracle_NTD_zero_five)[:, i]) for i in range(6)
]
best_dataframe_zero_five = pd.DataFrame(
np.array(final_scores_zero_five),
index=[
np.array([
'True Positives', 'False Positives', 'False Negatives',
'Precision', 'Recall', 'F measure'
])
],
columns=["Oracles ranks, at 0.5 seconds"])
display(best_dataframe_zero_five.T)
final_scores_three = [
np.mean(np.array(scores_oracle_NTD_three)[:, i]) for i in range(6)
]
best_dataframe_three = pd.DataFrame(
np.array(final_scores_three),
index=[
np.array([
'True Positives', 'False Positives', 'False Negatives',
'Precision', 'Recall', 'F measure'
])
],
columns=["Oracles ranks, at 3 seconds"])
display(best_dataframe_three.T)
return zero_five_array
def fixed_conditions_feature(dataset,
feature,
penalty_weight,
annotations_type="MIREX10",
subdivision=96,
penalty_func="modulo8",
legend=", on test dataset.",
convolution_type="eight_bands"):
"""
Segmentation results when segmenting directly the signal, where the penalty_weight is fixed before computation.
"""
if dataset == "full":
dataset_path = paths.path_entire_rwc
elif dataset == "odd_songs":
dataset_path = paths.path_odd_songs_rwc
elif dataset == "even_songs":
dataset_path = paths.path_even_songs_rwc
elif dataset == "debug":
dataset_path = paths.path_debug_rwc
else:
raise err.InvalidArgumentValueException(
f"Dataset type not understood: {dataset}") from None
list_songs = scr.load_RWC_dataset(dataset_path, annotations_type)
annotations_folder = "{}/{}".format(paths.path_annotation_rwc,
annotations_type)
hop_length = 32
hop_length_seconds = 32 / 44100
zero_five = []
three = []
for song_and_annotations in list_songs:
song_name = song_and_annotations[0].replace(".wav", "")
annot_path = "{}/{}".format(annotations_folder,
song_and_annotations[1])
annotations = dm.get_segmentation_from_txt(annot_path,
annotations_type)
references_segments = np.array(annotations)[:, 0:2]
bars, spectrogram = scr.load_or_save_spectrogram_and_bars(
paths.path_data_persisted_rwc,
"{}/{}".format(dataset_path, song_name), feature, hop_length)
tensor_spectrogram = tf.tensorize_barwise(spectrogram, bars,
hop_length_seconds,
subdivision)
unfolded = tl.unfold(tensor_spectrogram, 2)
autosimilarity = as_seg.get_autosimilarity(unfolded,
transpose=True,
normalize=True)
segments = as_seg.dynamic_convolution_computation(
autosimilarity,
penalty_weight=penalty_weight,
penalty_func=penalty_func,
convolution_type=convolution_type)[0]
segments_in_time = dm.segments_from_bar_to_time(segments, bars)
tp, fp, fn = dm.compute_rates_of_segmentation(references_segments,
segments_in_time,
window_length=0.5)
prec, rap, f_mes = dm.compute_score_of_segmentation(
references_segments, segments_in_time, window_length=0.5)
zero_five.append(
[tp, fp, fn,
round(prec, 4),
round(rap, 4),
round(f_mes, 4)])
tp, fp, fn = dm.compute_rates_of_segmentation(references_segments,
segments_in_time,
window_length=3)
prec, rap, f_mes = dm.compute_score_of_segmentation(
references_segments, segments_in_time, window_length=3)
three.append(
[tp, fp, fn,
round(prec, 4),
round(rap, 4),
round(f_mes, 4)])
final_res_sig_zero_five = np.array(
[np.mean(np.array(zero_five)[:, i]) for i in range(6)])
dataframe = pd.DataFrame(
final_res_sig_zero_five,
columns=["Results with 0.5 seconds tolerance window{}".format(legend)],
index=np.array([
'True Positives', 'False Positives', 'False Negatives',
'Precision', 'Recall', 'F measure'
]))
display(dataframe.T)
final_res_sig_three = np.array(
[np.mean(np.array(three)[:, i]) for i in range(6)])
dataframe = pd.DataFrame(
final_res_sig_three,
columns=["Results with 3 seconds tolerance window{}".format(legend)],
index=np.array([
'True Positives', 'False Positives', 'False Negatives',
'Precision', 'Recall', 'F measure'
]))
display(dataframe.T)
return final_res_sig_zero_five, final_res_sig_three
def final_results_fixed_conditions(dataset,
feature,
ranks,
penalty_weight,
init="tucker",
update_rule="hals",
beta=None,
n_iter_max=1000,
annotations_type="MIREX10",
subdivision=96,
penalty_func="modulo8",
convolution_type="eight_bands",
legend="in unknown conditions."):
"""
Segmentation results when ranks and penalty_weight are fixed before computation.
"""
annotations_folder = "{}/{}".format(paths.path_annotation_rwc,
annotations_type)
if dataset == "full":
dataset_path = paths.path_entire_rwc
elif dataset == "odd_songs":
dataset_path = paths.path_odd_songs_rwc
elif dataset == "even_songs":
dataset_path = paths.path_even_songs_rwc
elif dataset == "debug":
dataset_path = paths.path_debug_rwc
else:
raise err.InvalidArgumentValueException(
f"Dataset type not understood: {dataset}") from None
list_songs = scr.load_RWC_dataset(dataset_path, annotations_type)
hop_length = 32
hop_length_seconds = 32 / 44100
zero_five_results = []
three_results = []
deviation = []
for song_and_annotations in list_songs:
song_number = song_and_annotations[0].replace(".wav", "")
annot_path = "{}/{}".format(annotations_folder,
song_and_annotations[1])
annotations = dm.get_segmentation_from_txt(annot_path,
annotations_type)
references_segments = np.array(annotations)[:, 0:2]
bars, spectrogram = scr.load_or_save_spectrogram_and_bars(
paths.path_data_persisted_rwc, f"{dataset_path}/{song_number}",
feature, hop_length)
tensor_spectrogram = tf.tensorize_barwise(spectrogram, bars,
hop_length_seconds,
subdivision)
if update_rule == "hals":
persisted_arguments = f"_{song_number}_{feature}_{init}_{subdivision}"
elif update_rule == "mu":
persisted_arguments = f"mu_slow_{song_number}_beta{beta}_{feature}_{init}_{subdivision}_n_iter_max{n_iter_max}"
else:
raise err.InvalidArgumentValueException(
f"Update rule type not understood: {update_rule}")
q_factor = scr.NTD_decomp_as_script(paths.path_data_persisted_rwc,
persisted_arguments,
tensor_spectrogram,
ranks,
init=init,
update_rule=update_rule,
beta=beta)[1][2]
autosimilarity = as_seg.get_autosimilarity(q_factor,
transpose=True,
normalize=True)
segments = as_seg.dynamic_convolution_computation(
autosimilarity,
penalty_weight=penalty_weight,
penalty_func=penalty_func,
convolution_type=convolution_type)[0]
segments_in_time = dm.segments_from_bar_to_time(segments, bars)
tp, fp, fn = dm.compute_rates_of_segmentation(references_segments,
segments_in_time,
window_length=0.5)
prec, rap, f_mes = dm.compute_score_of_segmentation(
references_segments, segments_in_time, window_length=0.5)
zero_five_results.append(
[tp, fp, fn,
round(prec, 4),
round(rap, 4),
round(f_mes, 4)])
tp, fp, fn = dm.compute_rates_of_segmentation(references_segments,
segments_in_time,
window_length=3)
prec, rap, f_mes = dm.compute_score_of_segmentation(
references_segments, segments_in_time, window_length=3)
three_results.append(
[tp, fp, fn,
round(prec, 4),
round(rap, 4),
round(f_mes, 4)])
r_to_e, e_to_r = dm.compute_median_deviation_of_segmentation(
references_segments, segments_in_time)
deviation.append([r_to_e, e_to_r])
results_at_zero_five = np.array(
[np.mean(np.array(zero_five_results)[:, i]) for i in range(6)])
dataframe_zero_five = pd.DataFrame(
results_at_zero_five,
index=[
'True Positives', 'False Positives', 'False Negatives',
'Precision', 'Recall', 'F measure'
],
columns=[
f"Results of {feature} with 0.5 seconds tolerance window {legend}"
])
display(dataframe_zero_five.T)
results_at_three = np.array(
[np.mean(np.array(three_results)[:, i]) for i in range(6)])
dataframe_three = pd.DataFrame(
results_at_three,
index=[
'True Positives', 'False Positives', 'False Negatives',
'Precision', 'Recall', 'F measure'
],
columns=[
f"Results of {feature} with 3 seconds tolerance window {legend}"
])
display(dataframe_three.T)
# mean_deviation = np.array([np.mean(np.array(deviation)[:,i]) for i in range(2)])
# dataframe_deviation = pd.DataFrame(mean_deviation, index = ['Reference to Estimation mean deviation','Estimation to Reference mean deviation'], columns = ["Mean deviation between estimations and references{}".format(legend)])
# display(dataframe_deviation.T)
return results_at_zero_five, results_at_three
def several_ranks_with_cross_validation_of_param_RWC(
learning_dataset,
testing_dataset,
feature,
ranks_frequency,
ranks_rhythm,
ranks_pattern,
penalty_range,
init="tucker",
update_rule="hals",
beta=None,
n_iter_max=1000,
annotations_type="MIREX10",
penalty_func="modulo8",
convolution_type="eight_bands"):
"""
Segmentation results when ranks and penalty parameter are fitted by cross validation.
Results are shown for the test dataset.
"""
if learning_dataset == "odd_songs":
learning_dataset_path = paths.path_odd_songs_rwc
elif learning_dataset == "even_songs":
learning_dataset_path = paths.path_even_songs_rwc
elif learning_dataset == "debug":
learning_dataset_path = paths.path_debug_rwc
else:
raise err.InvalidArgumentValueException(
f"Dataset type not understood: {learning_dataset}") from None
if testing_dataset == "odd_songs":
testing_dataset_path = paths.path_odd_songs_rwc
elif testing_dataset == "even_songs":
testing_dataset_path = paths.path_even_songs_rwc
elif testing_dataset == "debug":
testing_dataset_path = paths.path_debug_rwc
else:
raise err.InvalidArgumentValueException(
f"Dataset type not understood: {testing_dataset_path}") from None
if learning_dataset == testing_dataset:
warnings.warn(
"Careful: using the same dataset as test and learn, normal?")
annotations_folder = "{}/{}".format(paths.path_annotation_rwc,
annotations_type)
hop_length = 32
hop_length_seconds = 32 / 44100
subdivision = 96
learning_dataset_songs = scr.load_RWC_dataset(learning_dataset_path,
annotations_type)
zero_five = -math.inf * np.ones(
(len(learning_dataset_songs), len(ranks_frequency), len(ranks_rhythm),
len(ranks_pattern), len(penalty_range), 1))
three = -math.inf * np.ones(
(len(learning_dataset_songs), len(ranks_frequency), len(ranks_rhythm),
len(ranks_pattern), len(penalty_range), 1))
for song_idx, song_and_annotations in enumerate(learning_dataset_songs):
#printmd('**Chanson courante: {}**'.format(song_and_annotations[0]))
song_number = song_and_annotations[0].replace(".wav", "")
annot_path = "{}/{}".format(annotations_folder,
song_and_annotations[1])
annotations = dm.get_segmentation_from_txt(annot_path,
annotations_type)
references_segments = np.array(annotations)[:, 0:2]
bars, spectrogram = scr.load_or_save_spectrogram_and_bars(
paths.path_data_persisted_rwc,
"{}/{}".format(learning_dataset_path,
song_number), feature, hop_length)
tensor_spectrogram = tf.tensorize_barwise(spectrogram, bars,
hop_length_seconds,
subdivision)
for w, rank_W in enumerate(ranks_frequency):
for h, rank_h in enumerate(ranks_rhythm):
for q, rank_q in enumerate(ranks_pattern):
ranks = [rank_W, rank_h, rank_q]
if update_rule == "hals":
persisted_arguments = f"_{song_number}_{feature}_{init}_{subdivision}"
elif update_rule == "mu":
persisted_arguments = f"mu_slow_{song_number}_beta{beta}_{feature}_{init}_{subdivision}_n_iter_max{n_iter_max}"
else:
raise err.InvalidArgumentValueException(
f"Update rule type not understood: {update_rule}")
q_factor = scr.NTD_decomp_as_script(
paths.path_data_persisted_rwc,
persisted_arguments,
tensor_spectrogram,
ranks,
init=init,
update_rule=update_rule,
beta=beta)[1][2]
autosimilarity = as_seg.get_autosimilarity(q_factor,
transpose=True,
normalize=True)
for p, penalty in enumerate(penalty_range):
segments = as_seg.dynamic_convolution_computation(
autosimilarity,
penalty_weight=penalty,
penalty_func=penalty_func,
convolution_type=convolution_type)[0]
segments_in_time = dm.segments_from_bar_to_time(
segments, bars)
prec, rap, f_mes = dm.compute_score_of_segmentation(
references_segments,
segments_in_time,
window_length=0.5)
zero_five[song_idx, w, h, q, p] = round(f_mes, 4)
prec, rap, f_mes = dm.compute_score_of_segmentation(
references_segments,
segments_in_time,
window_length=3)
three[song_idx, w, h, q, p] = round(f_mes, 4)
best_mean = 0
best_params = []
for w, rank_W in enumerate(ranks_frequency):
for h, rank_h in enumerate(ranks_rhythm):
for q, rank_q in enumerate(ranks_pattern):
for p, penalty in enumerate(penalty_range):
this_avg = np.mean(zero_five[:, w, h, q, p])
if this_avg > best_mean:
best_mean = this_avg
best_params = [rank_W, rank_h, rank_q, penalty]
display(
pd.DataFrame(np.array(
[best_params[0], best_params[1], best_params[2], best_params[3]]),
index=[
'Best rank for $W$', 'Best rank for $H$',
'Best rank for $Q$',
'Best lambda: ponderation parameter.'
],
columns=["Learned parameters"]).T)
learned_ranks = [best_params[0], best_params[1], best_params[2]]
results_at_zero_five, results_at_three = final_results_fixed_conditions(
testing_dataset,
feature,
learned_ranks,
best_params[3],
init=init,
update_rule=update_rule,
beta=beta,
n_iter_max=n_iter_max,
annotations_type=annotations_type,
penalty_func=penalty_func,
legend="on test dataset.",
convolution_type=convolution_type)
return best_params, results_at_zero_five, results_at_three
def segmentation_from_c_factor(c_factor,
normalize_autosimil=False,
segmentation="expanding_mixed"):
"""
Segmenting the C factor (Q matrix, the third one of the decomposition) by computing its autosimilarity.
This function is now deprecated as the segmentation measures are old and have been updated since.
Parameters
----------
c_factor : numpy array
The third factor of the decomposition (for our case).
normalize_autosimil : boolean, optional
Whether to normalize the autosimilarity matrix or not.
The default is False.
segmentation : String, optional
Type of the segmentation:
- novelty: novelty segmentation
- expanding_convolution: segmentation based on the dynamic convolutionnal cost programming algorithm
- expanding_mixed: segmentation based on the dynamic convolutionnal cost programming algorithm with novelty penalty on each point (mixed algorithm)
The default is "expanding_mixed".
Raises
------
NotImplementedError
If a non specified type of segmentation is chosen.
Returns
-------
list of tuples
The segmentation of the autosimilarity matrix.
"""
autosimilarity = as_seg.get_autosimilarity(c_factor,
transpose=True,
normalize=normalize_autosimil)
if segmentation == "novelty":
ker_size = 16
novelty = as_seg.novelty_computation(autosimilarity, ker_size)
ends = as_seg.select_highest_peaks_thresholded_indexes(novelty,
percentage=0.22)
ends.append(len(autosimilarity) - 1)
return dm.frontiers_to_segments(ends)
if segmentation == "novelty_max_slope":
ker_size = 16
novelty = as_seg.novelty_computation(autosimilarity, ker_size)
ponderated_novelty = as_seg.values_as_slop(novelty, choice_func=max)
ends = as_seg.select_highest_peaks_thresholded_indexes(
ponderated_novelty, percentage=0.08)
ends.append(len(autosimilarity) - 1)
return dm.frontiers_to_segments(ends)
if segmentation == "novelty_min_slope":
ker_size = 16
novelty = as_seg.novelty_computation(autosimilarity, ker_size)
ponderated_novelty = as_seg.values_as_slop(novelty, choice_func=min)
ends = as_seg.select_highest_peaks_thresholded_indexes(
ponderated_novelty, percentage=0.16)
ends.append(len(autosimilarity) - 1)
return dm.frontiers_to_segments(ends)
if segmentation == "novelty_mean_slope":
ker_size = 16
novelty = as_seg.novelty_computation(autosimilarity, ker_size)
ponderated_novelty = as_seg.values_as_slop(novelty,
choice_func=as_seg.mean)
ends = as_seg.select_highest_peaks_thresholded_indexes(
ponderated_novelty, percentage=0.13)
ends.append(len(autosimilarity) - 1)
return dm.frontiers_to_segments(ends)
elif segmentation == "expanding_convolution":
return as_seg.dynamic_convolution_computation(autosimilarity, mix=1)[0]
elif segmentation == "expanding_mixed":
return as_seg.dynamic_convolution_computation(autosimilarity,
mix=0.5)[0]
else:
raise NotImplementedError("Other types are not implemtend yet")
def run_NTD_on_this_song(persisted_path,
persisted_arguments,
tensor_spectrogram,
ranks,
reference_segments,
bars,
init="tucker",
plotting=True):
"""
Computes (or load) a NTD and returns segmentation scores associated with it.
Segmentation techniques are probably outdated though.
Parameters
----------
persisted_path : String
Path of the persisted decompositions and bars.
persisted_arguments : String
Identifier of the specific NTD to load/save.
tensor_spectrogram : tensorly tensor
The tensor to decompose.
ranks : list of integers
Ranks of this decomposition.
reference_segments : list of tuple of floats
Annotated segments.
bars : list of tuple of floats
Bars of the songs.
init : String, optional
The type of initialization of the NTD.
See the NTD module to have more information regarding initialization.
The default is "tucker",
meaning that the factors will be initialized by HOSVD.
plotting : boolean, optional
DESCRIPTION. The default is True.
Returns
-------
tuple of lists
Nested list of segmentation scores at 0.5 and 3 seconds.
"""
core, factors = NTD_decomp_as_script(persisted_path,
persisted_arguments,
tensor_spectrogram,
ranks,
init=init)
if plotting:
plot_spec_with_annotations_abs_ord(
as_seg.get_autosimilarity(factors[2],
transpose=True,
normalize=True),
dm.frontiers_from_time_to_bar(
dm.segments_to_frontiers(reference_segments), bars),
cmap=cm.Greys)
return compute_all_results(factors[2],
reference_segments,
bars,
window_length=0.5), compute_all_results(
factors[2],
reference_segments,
bars,
window_length=3)
