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)