AUTHORS

-Axel MARMORET : Developer
-Jérémy E COHEN : Contributor
+Axel MARMORET : Developer
+Jérémy E COHEN : Contributor
 Frédéric BIMBOT : Contributor
\ No newline at end of file

For MSAF.txt

+In the files vol.py and sivm_search.py, in the folder ~\AppData\Local\Continuum\anaconda3\envs\neural_net\lib\site-packages\msaf\pymf\ (using Anaconda to handle the MSAF distribution), I had to change:
+from scipy.misc import factorial
+into:  
+try:
+    from scipy.misc import factorial
+except:
+    from scipy.special import factorial
\ No newline at end of file

README.md

@@ -16,9 +16,7 @@ A tutorial notebook presenting the most important components of this toolbox is
 
 ## Experimental notebook ##
 
-Experimental notebooks are available in the folder "Notebooks". They present the code used to compute the main experiments of the paper, in order to improve the reproducibility. Please tell me if any problem would appear when trying to launch them.
-
-Experimental Notebooks requires some pre-computed data to work, which can be found on zenodo: https://zenodo.org/records/10168387. DOI: 10.5281/zenodo.10168386.
+A Tutorial notebook is presented in the "Notebooks" folder. In older version of the code, you may find Notebooks presenting experiments associated with publications.
 
 ## Data ##
 
@@ -40,7 +38,7 @@ In the IEEE style, this should be cited as: A. Marmoret, J.E. Cohen, and F. Bimb
 
 ## Credits ##
 
-Code was created by Axel Marmoret (<axel.marmoret@gmail.com>), and strongly supported by Jeremy E. Cohen (<jeremy.cohen@cnrs.fr>).
+Code was created by Axel Marmoret (<axel.marmoret@imt-atlantique.fr>), and strongly supported by Jeremy E. Cohen (<jeremy.cohen@cnrs.fr>).
 
 The technique in itself was also developed by Frédéric Bimbot (<bimbot@irisa.fr>).
 

as_seg/CBM_algorithm.py

@@ -172,52 +172,6 @@ def convolutionnal_cost(cropped_autosimilarity, kernels):
     #return np.mean(np.multiply(kern,cropped_autosimilarity))
     return np.sum(np.multiply(kern,cropped_autosimilarity)) / p**2
     
-    
-def compute_cbm_sum_normalization(autosimilarity, min_size = 1, max_size = 32, penalty_weight = 1, penalty_func = "modulo8", bands_number = None):
-    scores = [-math.inf for i in range(len(autosimilarity))]
-    segments_best_starts = [None for i in range(len(autosimilarity))]
-    segments_best_starts[0] = 0
-    scores[0] = 0
-    kernels = compute_all_kernels(max_size, bands_number = bands_number)
-    max_conv_eight = np.amax(convolution_entire_matrix_computation(autosimilarity, kernels))
-    
-    for current_idx in range(1, len(autosimilarity)): # Parse all indexes of the autosimilarity
-        for possible_start_idx in possible_segment_start(current_idx, min_size = min_size, max_size = max_size):
-            if possible_start_idx < 0:
-                raise err.ToDebugException("Invalid value of start index, shouldn't happen.") from None
-                
-            # Convolutionnal cost between the possible start of the segment and the current index (entire segment)
-            cropped_autosimilarity = autosimilarity[possible_start_idx:current_idx,possible_start_idx:current_idx]
-            kern = kernels[len(cropped_autosimilarity)]
-            if np.sum(kern) == 0:
-                conv_cost = 0
-            else:
-                conv_cost = np.sum(np.multiply(kern,cropped_autosimilarity)) / (np.sum(kern) + len(cropped_autosimilarity))
-                        
-            segment_length = current_idx - possible_start_idx
-            penalty_cost = penalty_cost_from_arg(penalty_func, segment_length)            
-            
-            this_segment_cost = conv_cost * segment_length - penalty_cost * penalty_weight * max_conv_eight
-            # Note: conv_eight is not normalized by its size (not a problem in itself as size is contant, but generally not specified in formulas).
-
-            if possible_start_idx == 0: # Avoiding errors, as scores values are initially set to -inf.
-                if this_segment_cost > scores[current_idx]: # This segment is of larger score
-                    scores[current_idx] = this_segment_cost
-                    segments_best_starts[current_idx] = 0
-            else:
-                if scores[possible_start_idx] + this_segment_cost > scores[current_idx]: # This segment is of larger score
-                    scores[current_idx] = scores[possible_start_idx] + this_segment_cost
-                    segments_best_starts[current_idx] = possible_start_idx
-
-    segments = [(segments_best_starts[len(autosimilarity) - 1], len(autosimilarity) - 1)]
-    precedent_frontier = segments_best_starts[len(autosimilarity) - 1] # Because a segment's start is the previous one's end.
-    while precedent_frontier > 0:
-        segments.append((segments_best_starts[precedent_frontier], precedent_frontier))
-        precedent_frontier = segments_best_starts[precedent_frontier]
-        if precedent_frontier == None:
-            raise err.ToDebugException("Well... The dynamic programming algorithm took an impossible path, so it failed. Understand why.") from None
-    return segments[::-1], scores[-1]
-
 def convolution_entire_matrix_computation(autosimilarity_array, kernels, kernel_size = 8):
     """
     Computes the convolution measure on the entire autosimilarity matrix, with a defined and fixed kernel size.
@@ -330,164 +284,89 @@ def possible_segment_start(idx, min_size = 1, max_size = None):
             return range(0, idx - min_size + 1)
         else:
             return []
+        
+# %% Scikit-learn class
+# Author: Axel Marmoret
+# 
+# Adapted from: https://scikit-learn.org/stable/auto_examples/developing_estimators/sklearn_is_fitted.html, Author: Kushan <kushansharma1@gmail.com>
+#
+# License: BSD 3 clause
 
-# %% Sandbox
-def dynamic_convolution_computation_test_line(autosimilarity, line_conv_weight = 1, min_size = 2, max_size = 36, novelty_kernel_size = 16, penalty_weight = 1, penalty_func = "modulo8", convolution_type = "eight_bands"):
-    """
-    Segmentation algo with inline convolution test, doesn't work that much in practice.
-    """
-    costs = [-math.inf for i in range(len(autosimilarity))]
-    segments_best_starts = [None for i in range(len(autosimilarity))]
-    segments_best_starts[0] = 0
-    costs[0] = 0
-
-    kernels = compute_all_kernels(max_size, convolution_type = convolution_type)
-    full_kernels = compute_full_kernels(max_size, convolution_type = convolution_type)
-    #novelty = novelty_computation(autosimilarity, novelty_kernel_size)
-    conv_eight = convolution_entire_matrix_computation(autosimilarity, kernels)
-    
-    for current_idx in range(1, len(autosimilarity)): # Parse all indexes of the autosimilarity
-        for possible_start_idx in possible_segment_start(current_idx, min_size = min_size, max_size = max_size):
-            if possible_start_idx < 0:
-                raise err.ToDebugException("Invalid value of start index.")
-                
-            # Convolutionnal cost between the possible start of the segment and the current index (entire segment)
-            conv_cost = convolutionnal_cost(autosimilarity[possible_start_idx:current_idx,possible_start_idx:current_idx], kernels)
-
-            # Novelty cost, computed with a fixed kernel (doesn't make sense otherwise), on the end of the segment
-            #nov_cost = novelty[current_idx]
-            
-            segment_length = current_idx - possible_start_idx
-            penalty_cost = penalty_cost_from_arg(penalty_func, segment_length)            
-            
-            current_line_conv_max = 0
-            # if possible_start_idx >= segment_length:
-            #     for before_start in range(0, possible_start_idx - segment_length + 1):
-            #         line_conv_cost = convolutionnal_cost(autosimilarity[possible_start_idx:current_idx,before_start:before_start + segment_length], full_kernels)
-            #         if line_conv_cost > current_line_conv_max:
-            #             current_line_conv_max = line_conv_cost
-            
-            # if current_idx + segment_length < len(autosimilarity):
-            #     for after_start in range(current_idx, len(autosimilarity) - segment_length):
-            #         line_conv_cost = convolutionnal_cost(autosimilarity[possible_start_idx:current_idx,after_start:after_start + segment_length], full_kernels)
-            #         if line_conv_cost > current_line_conv_max:
-            #             current_line_conv_max = line_conv_cost
-            
-            mat_vec = []
-            if possible_start_idx >= segment_length:
-                for before_start in range(0, possible_start_idx - segment_length + 1):
-                    mat_vec.append(autosimilarity[possible_start_idx:current_idx,before_start:before_start + segment_length].flatten())
-
-            if current_idx + segment_length < len(autosimilarity):
-                for after_start in range(current_idx, len(autosimilarity) - segment_length):
-                    mat_vec.append(autosimilarity[possible_start_idx:current_idx,after_start:after_start + segment_length].flatten())
-
-            if mat_vec == []:
-                current_line_conv_max = 0
-            else:
-                kern = full_kernels[segment_length]
-                convs_on_line = np.matmul(kern.reshape(1,segment_length**2), np.array(mat_vec).T)                
-                current_line_conv_max = np.amax(convs_on_line) / segment_length**2
-            
-            this_segment_cost = (conv_cost + line_conv_weight * current_line_conv_max) * segment_length - penalty_cost * penalty_weight * np.max(conv_eight)
-            # Note: the length of the segment does not appear in conv_eight (not a problem in itself as size is contant, but generally not specified in formulas).
-
-            # Avoiding errors, as segment_cost are initially set to -inf.
-            if possible_start_idx == 0:
-                if this_segment_cost > costs[current_idx]:
-                    costs[current_idx] = this_segment_cost
-                    segments_best_starts[current_idx] = 0
-            else:
-                if costs[possible_start_idx] + this_segment_cost > costs[current_idx]:
-                    costs[current_idx] = costs[possible_start_idx] + this_segment_cost
-                    segments_best_starts[current_idx] = possible_start_idx
-
-    segments = [(segments_best_starts[len(autosimilarity) - 1], len(autosimilarity) - 1)]
-    precedent_frontier = segments_best_starts[len(autosimilarity) - 1] # Because a segment's start is the previous one's end.
-    while precedent_frontier > 0:
-        segments.append((segments_best_starts[precedent_frontier], precedent_frontier))
-        precedent_frontier = segments_best_starts[precedent_frontier]
-        if precedent_frontier == None:
-            raise err.ToDebugException("Well... Viterbi took an impossible path, so it failed. Understand why.") from None
-    return segments[::-1], costs[-1]
+from sklearn.base import BaseEstimator, ClassifierMixin
 
+import as_seg.autosimilarity_computation as as_comp
+import as_seg.data_manipulation as dm
 
-def compute_all_kernels_oldway(max_size, convolution_type = "full"):
+class CBMEstimator(BaseEstimator, ClassifierMixin):
     """
-    DEPRECATED but some ideas may be worth the shot.
+    Scikit-learn class for the CBM algorithm. May be used for practicity, following the scikit-learn API.
+    """
+    def __init__(self, similarity_function="cosine", max_size=32, penalty_weight=1, penalty_func="modulo8", bands_number=7):
+        """
+        Constructor of the CBM estimator.
+
+        Parameters
+        ----------
+        similarity_function : string, optional
+            The similarity function to use for computing the autosimilarity.
+            The default is "cosine".
+        max_size : integer, optional
+            The maximal size of segments.
+            The default is 32.
+        penalty_weight : float, optional
+            The ponderation parameter for the penalty function.
+            The default is 1.
+        penalty_func : string, optional
+            The type of penalty function to use.
+            The default is "modulo8".
+        bands_number : positive integer or None, optional
+            The number of bands in the kernel.
+            For the full kernel, bands_number must be set to None
+            (or higher than the maximal size, but cumbersome)
+            See [1] for details.
+            The default is 7.
+        """
+        self.similarity_function = similarity_function
+        self.max_size = max_size
+        self.penalty_weight = penalty_weight
+        self.penalty_func = penalty_func
+        self.bands_number = bands_number
+        self.algorithm_name = "CBM"
+
+    def predict(self, barwise_features):
+        """
+        Perform Predictions
+
+        If the estimator is not fitted, then raise NotFittedError
+        """
+        ssm_matrix = as_comp.switch_autosimilarity(barwise_features, similarity_type=self.similarity_function)
+        segments = compute_cbm(ssm_matrix, max_size=self.max_size, penalty_weight=self.penalty_weight, 
+                               penalty_func=self.penalty_func, bands_number = self.bands_number)[0]
+        return segments
     
-    Precomputes all kernels of size 0 ([0]) to max_size, and feed them to the Dynamic Progamming algorithm.
+    def predict_in_seconds(self, barwise_features, bars):
+        """
+        Perform Predictions, and convert the segments from bars to seconds.
+
+        If the estimator is not fitted, then raise NotFittedError
+        """
+        segments = self.predict(barwise_features)
+        return dm.segments_from_bar_to_time(segments, bars)
     
-    This is used for acceleration purposes.
-
-    Parameters
-    ----------
-    max_size : integer
-        The maximal size (included) for kernels.
-    convolution_type: string
-        The type of convolution. (to explicit)
-        Possibilities are :
-            - "full" : squared matrix entirely composed of one, except on the diagonal where it's zero.
-            The associated convolution cost for a segment (b_1, b_2) will be
-            .. math::
-                c_{b_1,b_2} = \\frac{1}{b_2 - b_1 + 1}\\sum_{i,j = 0, i \\ne j}^{n - 1}  a_{i + b_1, j + b_1}
-            - "4_bands" : squared matrix where the only nonzero values are ones on the 
-            4 upper- and 4 sub-diagonals surrounding the main diagonal.
-            The associated convolution cost for a segment (b_1, b_2) will be
-            .. math::
-                c_{b_1,b_2} = \\frac{1}{b_2 - b_1 + 1}\\sum_{i,j = 0, 1 \\leq |i - j| \\leq 4}^{n - 1}  a_{i + b_1, j + b_1}
-            - "mixed" : sum of both previous kernels, i.e. values are zero on the diagonal,
-            2 on the 4 upper- and 4 sub-diagonals surrounding the main diagonal, and 1 elsewhere.
-            The associated convolution cost for a segment (b_1, b_2) will be
-            .. math::
-                c_{b_1,b_2} = \\frac{1}{b_2 - b_1 + 1}(2*\\sum_{i,j = 0, 1 \\leq |i - j| \\leq 4}^{n - 1}  a_{i + b_1, j + b_1} \\ + \sum_{i,j = 0, |i - j| > 4}^{n - 1}  a_{i + b_1, j + b_1})
-        
-    Returns
-    -------
-    kernels : array of arrays (which are kernels)
-        All the kernels, of size 0 ([0]) to max_size.
-
-    """
-    kernels = [[0]]
-    for p in range(1,max_size + 1):
-        if p < 4:
-            kern = np.ones((p,p)) - np.identity(p)
-        # elif convolution_type == "7_bands" or convolution_type == "mixed_7_bands":
-        #     if p < 8:
-        #         kern = np.ones((p,p)) - np.identity(p)
-        #     else:
-        #         # Diagonal where only the six subdiagonals surrounding the main diagonal is one
-        #         k = np.array([np.ones(p-7),np.ones(p-6),np.ones(p-5),np.ones(p-4),np.ones(p-3),np.ones(p-2),np.ones(p-1),np.zeros(p),np.ones(p-1),np.ones(p-2),np.ones(p-3),np.ones(p-4),np.ones(p-5),np.ones(p-6),np.ones(p-7)], dtype=object)
-        #         offset = [-7,-6,-5,-4,-3,-2,-1,0,1,2,3, 4, 5, 6, 7]
-        #         if convolution_type == "14_bands":
-        #             kern = diags(k,offset).toarray()
-        #         else:
-        #             kern = np.ones((p,p)) - np.identity(p) + diags(k,offset).toarray()
-        else:
-            if convolution_type == "full":
-                # Full kernel (except for the diagonal)
-                kern = np.ones((p,p)) - np.identity(p)
-            elif convolution_type == "4_bands":
-                # Diagonal where only the eight subdiagonals surrounding the main diagonal is one
-                k = np.array([np.ones(p-4),np.ones(p-3),np.ones(p-2),np.ones(p-1),np.zeros(p),np.ones(p-1),np.ones(p-2),np.ones(p-3),np.ones(p-4)],dtype=object)
-                offset = [-4,-3,-2,-1,0,1,2,3,4]
-                kern = diags(k,offset).toarray()
-            elif convolution_type == "mixed":
-                # Sum of both previous kernels
-                k = np.array([np.ones(p-4),np.ones(p-3),np.ones(p-2),np.ones(p-1),np.zeros(p),np.ones(p-1),np.ones(p-2),np.ones(p-3),np.ones(p-4)],dtype=object)
-                offset = [-4,-3,-2,-1,0,1,2,3,4]
-                kern = np.ones((p,p)) - np.identity(p) + diags(k,offset).toarray()
-            elif convolution_type == "3_bands":
-                # Diagonal where only the six subdiagonals surrounding the main diagonal is one
-                k = np.array([np.ones(p-3),np.ones(p-2),np.ones(p-1),np.zeros(p),np.ones(p-1),np.ones(p-2),np.ones(p-3)],dtype=object)
-                offset = [-3,-2,-1,0,1,2,3]
-                kern = diags(k,offset).toarray()
-            elif convolution_type == "mixed_3_bands":
-                # Sum of both previous kernels
-                k = np.array([np.ones(p-3),np.ones(p-2),np.ones(p-1),np.zeros(p),np.ones(p-1),np.ones(p-2),np.ones(p-3)],dtype=object)
-                offset = [-3,-2,-1,0,1,2,3]
-                kern = np.ones((p,p)) - np.identity(p) + diags(k,offset).toarray()
-            else:
-                raise err.InvalidArgumentValueException(f"Convolution type not understood: {convolution_type}.")
-        kernels.append(kern)
-    return kernels
+    def predict_in_seconds_this_autosimilarity(self, ssm_matrix, bars):
+        """
+        Perform Predictions on a given autosimilarity matrix, and convert the segments from bars to seconds.
+
+        If the estimator is not fitted, then raise NotFittedError
+        """
+        segments = compute_cbm(ssm_matrix, max_size=self.max_size, penalty_weight=self.penalty_weight, 
+                               penalty_func=self.penalty_func, bands_number = self.bands_number)[0]
+        return dm.segments_from_bar_to_time(segments, bars)
+
+    def score(self, predictions, annotations):
+        """
+        Compute the score of the predictions
+        """
+        close_tolerance = dm.compute_score_of_segmentation(annotations, predictions, window_length=0.5)
+        large_tolerance = dm.compute_score_of_segmentation(annotations, predictions, window_length=3)
+        return close_tolerance, large_tolerance
\ No newline at end of file

as_seg/__init__.py

@@ -2,9 +2,8 @@ from . import autosimilarity_computation
 from . import barwise_input
 from . import data_manipulation
 from . import CBM_algorithm
-#from . import foote_novelty
 
-from .model import current_plot
+from .model import common_plot
+from .model import dataloaders
 from .model import errors
 from .model import signal_to_spectrogram
-from .model import display_results

as_seg/barwise_input.py

@@ -12,10 +12,8 @@ See [1 - Chapter 2.4] or [2] for more information.
 
 References
 ----------
-[1] Unsupervised Machine Learning Paradigms for the Representation of Music Similarity and Structure, 
-PhD Thesis Marmoret Axel 
-(not uploaded yet but will be soon!)
-(You should check the website hal.archives-ouvertes.fr/ in case this docstring is not updated with the reference.)
+[1] Marmoret, A. (2022). Unsupervised Machine Learning Paradigms for the Representation of Music Similarity and Structure (Doctoral dissertation, Université Rennes 1).
+https://theses.hal.science/tel-04589687
 
 [2] Marmoret, A., Cohen, J.E, and Bimbot, F., "Barwise Compression Schemes 
 for Audio-Based Music Structure Analysis"", in: 19th Sound and Music Computing Conference, 
@@ -31,6 +29,19 @@ import librosa
 
 # %% Spectrograms to tensors
 # !!! Be extremely careful with the organization of modes, which can be either Frequency-Time at barscale-Bars (FTB) or Bars-Frequency-Time at barscale (BFT) depending on the method.
+def spectrogram_to_tensor_barwise(spectrogram, bars, hop_length_seconds, subdivision, mode_order="BFT", subset_nb_bars = None):
+    """
+    Spectrogram to tensor-spectrogram, with the order of modes defined by the mode_order parameter.
+    """
+    if mode_order == "BFT":
+        return tensorize_barwise_BFT(spectrogram, bars, hop_length_seconds, subdivision, subset_nb_bars)
+    
+    elif mode_order == "FTB":
+        return tensorize_barwise_FTB(spectrogram, bars, hop_length_seconds, subdivision, subset_nb_bars)
+    
+    else:
+        raise err.InvalidArgumentValueException(f"Unknown mode order: {mode_order}.")
+
 def tensorize_barwise_BFT(spectrogram, bars, hop_length_seconds, subdivision, subset_nb_bars = None):
     """
     Returns a 3rd order tensor-spectrogram from the original spectrogram and bars starts and ends.
@@ -123,6 +134,9 @@ def tensorize_barwise_FTB(spectrogram, bars, hop_length_seconds, subdivision, su
 
 # %% Tensors to spectrograms
 def tensor_barwise_to_spectrogram(tensor, mode_order = "BFT", subset_nb_bars = None):
+    """
+    Return a spectrogram from a tensor-spectrogram, with the order of modes defined by the mode_order parameter.
+    """
     if subset_nb_bars is not None:
         tensor = barwise_subset_this_tensor(tensor, subset_nb_bars, mode_order = mode_order)
     
@@ -136,6 +150,9 @@ def tensor_barwise_to_spectrogram(tensor, mode_order = "BFT", subset_nb_bars = N
         raise err.InvalidArgumentValueException(f"Unknown mode order: {mode_order}.")
 
 def barwise_subset_this_tensor(tensor, subset_nb_bars, mode_order = "BFT"):
+    """
+    Keep only the subset_nb_bars first bars in the tensor.
+    """
     if mode_order == "BFT":
         return tensor[:subset_nb_bars]
    
@@ -146,6 +163,9 @@ def barwise_subset_this_tensor(tensor, subset_nb_bars, mode_order = "BFT"):
         raise err.InvalidArgumentValueException(f"Unknown mode order: {mode_order}.")
     
 def get_this_bar_tensor(tensor, bar_idx, mode_order = "BFT"):
+    """
+    Return one particular bar of the tensor.
+    """
     if mode_order == "BFT":
         return tensor[bar_idx]
    
@@ -182,6 +202,9 @@ def barwise_TF_matrix(spectrogram, bars, hop_length_seconds, subdivision, subset
     return tl.unfold(tensor_spectrogram, 0)
 
 def barwise_subset_this_TF_matrix(matrix, subset_nb_bars):
+    """
+    Keep only the subset_nb_bars first bars in the Barwise TF matrix.
+    """
     assert subset_nb_bars is not None
     return matrix[:subset_nb_bars]
 
@@ -211,6 +234,9 @@ def TF_vector_to_spectrogram(vector, frequency_dimension, subdivision):
     return tl.fold(vector, 0, (frequency_dimension,subdivision))
 
 def TF_matrix_to_spectrogram(matrix, frequency_dimension, subdivision, subset_nb_bars = None):
+    """
+    Encapsulating the conversion from a Barwise TF matrix to a spectrogram.
+    """
     spectrogram_content = None
     if subset_nb_bars is not None:
         matrix = barwise_subset_this_TF_matrix(matrix, subset_nb_bars)
@@ -222,10 +248,13 @@ def TF_matrix_to_spectrogram(matrix, frequency_dimension, subdivision, subset_nb
 
 # Tensor to Barwise TF
 def tensor_barwise_to_barwise_TF(tensor, mode_order = "BFT"):
+    """
+    Return the Barwise TF matrix from a tensor-spectrogram, with the order of modes defined by the mode_order parameter.
+    """
     # Barmode: 0 for BTF, 2 for FTB
-    if mode_order == "BFT": # Checked
+    if mode_order == "BFT":
         return tl.unfold(tensor, 0)
-    elif mode_order == "FTB": # Checked
+    elif mode_order == "FTB":
         return tl.unfold(tensor, 2)
     else:
         raise err.InvalidArgumentValueException(f"Unknown mode order: {mode_order}.")

as_seg/example.py

@@ -33,7 +33,7 @@ import as_seg.autosimilarity_computation as as_computation
 import as_seg.CBM_algorithm as cbm
 
 # Plotting module
-from as_seg.model.current_plot import *
+from as_seg.model.common_plot import *
 
 # %% Loading annotations and defining the audio path
 path_to_beatles_dataset = '/home/a23marmo/datasets/beatles' # To change
@@ -56,11 +56,13 @@ hop_length = 32 # Oversampling the spectrogram, to select frames which will be e
 hop_length_seconds = hop_length/sampling_rate # As bars are in seconds, we convert this hop length in seconds.
 subdivision_bars = 96 # The number of time samples to consider in each bar.
 
-log_mel = signal_to_spectrogram.get_spectrogram(the_signal, sampling_rate, "log_mel", hop_length = hop_length) # Log_mel spectrogram
+feature_object = signal_to_spectrogram.FeatureObject(sr=sampling_rate, feature="log_mel", hop_length=hop_length, mel_grill=True)
+log_mel = feature_object.get_spectrogram(the_signal) # Log_mel spectrogram
+
+barwise_TF = bi.barwise_TF_matrix(log_mel, bars, hop_length_seconds, subdivision_bars)
 
 # %% Cosine autosimilarity
-barwise_TF_cosine = bi.barwise_TF_matrix(log_mel, bars, hop_length_seconds, subdivision_bars)
-barwise_TF_cosine_autosimilarity = as_computation.switch_autosimilarity(barwise_TF_cosine, "cosine")
+barwise_TF_cosine_autosimilarity = as_computation.switch_autosimilarity(barwise_TF, "cosine")
 #Alternatively, one could use: as_computation.get_cosine_autosimilarity(barwise_TF_cosine)
 plot_me_this_spectrogram(barwise_TF_cosine_autosimilarity, title = "Cosine autosimilarity of the Barwise TF matrix")
 
@@ -74,8 +76,7 @@ score_cbm_cosine_three = dm.compute_score_of_segmentation(references_segments, s
 print(f"Score with 3 seconds tolerance: Precision {score_cbm_cosine_three[0]}, Recall {score_cbm_cosine_three[1]}, F measure {score_cbm_cosine_three[2]}")
 
 # %% Autocorrelation/Covariance autosimilarity
-barwise_TF_covariance = bi.barwise_TF_matrix(log_mel, bars, hop_length_seconds, subdivision_bars)
-barwise_TF_covariance_autosimilarity = as_computation.switch_autosimilarity(barwise_TF_covariance, "covariance")
+barwise_TF_covariance_autosimilarity = as_computation.switch_autosimilarity(barwise_TF, "covariance")
 plot_me_this_spectrogram(barwise_TF_covariance_autosimilarity, title = "Covariance autosimilarity of the Barwise TF matrix")
 
 # %% Running the CBM on the autosimilarity matrix
@@ -88,8 +89,7 @@ score_cbm_covariance_three = dm.compute_score_of_segmentation(references_segment
 print(f"Score with 3 seconds tolerance: Precision {score_cbm_covariance_three[0]}, Recall {score_cbm_covariance_three[1]}, F measure {score_cbm_covariance_three[2]}")
 
 # %% RBF autosimilarity
-barwise_TF_rbf = bi.barwise_TF_matrix(log_mel, bars, hop_length_seconds, subdivision_bars)
-barwise_TF_rbf_autosimilarity = as_computation.switch_autosimilarity(barwise_TF_rbf, "RBF")
+barwise_TF_rbf_autosimilarity = as_computation.switch_autosimilarity(barwise_TF, "RBF")
 plot_me_this_spectrogram(barwise_TF_rbf_autosimilarity, title = "RBF autosimilarity of the Barwise TF matrix")
 
 # %% Running the CBM on the autosimilarity matrix

as_seg/model/__init__.py

-# from . import current_plot
-# from . import errors
-# from . import features
\ No newline at end of file

as_seg/model/display_results.py → as_seg/scripts/display_results.py

+"""
+Script to display experimental results in a nice format.
+
+I should probably use scikit-learn's GridSearchCV, TODO.
+"""
+
 import pandas as pd
 from IPython.display import display
 import numpy as np