def __init__(self, inputSamples="samples", outputOnsetDetection="onsetDetection", parameterHopLength=512, parameterBacktrack="True", cachingLevel=2, forceRefreshCache=False): self.parameters = {"hopLength": Parameter(parameterHopLength), "backtrack": Parameter(parameterBacktrack)} self.inputs = [inputSamples] self.outputs = [outputOnsetDetection] self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache
def __init__( self, parameterHopLength=512, parameterNieto=False, # Use nieto's implementation # parameterScale="Power", inputSamples="samples", outputPcp="pcp", cachingLevel=2, forceRefreshCache=False): self.parameters = {"hopLength": Parameter(parameterHopLength), "nieto": Parameter(parameterNieto)} self.inputs = [inputSamples] self.outputs = [outputPcp] self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache
def __init__(self, parameterMedianSize=16, parameterRelativeThreshold=0.5, parameterThresholdIndex=1, parameterMinDistance=0, inputSignal="barMSE", outputPeaks="peaks", cachingLevel=2, forceRefreshCache=False): """ Estimator computing returning peaks from a signal. Based on the method from MAXIMUM FILTER VIBRATO SUPPRESSION FOR ONSET DETECTION 2013 Parameters ---------- parameterRelativeThreshold (optional float): return the maximum value of a continuous window exceeding the threshold in % of the max value parameterThresholdIndex Limit the search of the maximum value in this part of the signal (1 = 100% of the track, 0.5 = 50% from the start of the track) parameterMinDistance return the highest peaks in a window of this size, This value filter peaks within distance striclty inferior. (If min distance is set to 8 ticks, two peaks 8 ticks appart can be return) parameterMedianSize When computing peaks without a static threshold windowSize (optional int): distance (optional int) min distance in indexes between two peaks """ self.parameters = { "medianSize": Parameter(parameterMedianSize), "relativeThreshold": Parameter(parameterRelativeThreshold), "thresholdIndex": Parameter(parameterThresholdIndex), "minDistance": Parameter(parameterMinDistance) } self.inputs = [inputSignal] self.outputs = [outputPeaks] self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache
def __init__(self, parameterWindowSize=8, parameterAbsoluteDiff=True, parameterGaussianCoef=5, inputSamples="normalizedBarMSE", outputNovelty="noveltyMSE", cachingLevel=2, forceRefreshCache=False): self.parameters = { "windowSize": Parameter(parameterWindowSize), "absoluteDiff": Parameter(parameterAbsoluteDiff), "gaussianCoef": Parameter(parameterGaussianCoef) } self.inputs = [inputSamples] self.outputs = [outputNovelty] self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache
def __init__(self, parameterHopLength=512, parameterBinNumber=84, parameterScale="Power", inputSamples="samples", outputCqt="cqt", cachingLevel=2, forceRefreshCache=False): self.parameters = { "hopLength": Parameter(parameterHopLength), "binNumber": Parameter(parameterBinNumber), "scale": Parameter(parameterScale) } self.inputs = [inputSamples] self.outputs = [outputCqt] self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache
def __init__(self, parameterWindowSize=16, parameterDistanceMetric="seuclidean", parameterDebugViz=False, parameterAddZerosStart=True, inputSamples="normalizedBarMSE", outputNovelty="noveltyMSE", cachingLevel=2, forceRefreshCache=False): self.parameters = { "windowSize": Parameter(parameterWindowSize), "distanceMetric": Parameter(parameterDistanceMetric), "debugViz": Parameter(parameterDebugViz), "addZerosStart": Parameter(parameterAddZerosStart) } self.inputs = [inputSamples] self.outputs = [outputNovelty] self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache
def __init__(self, parameterDiffThreshold=5, parameterRatioThreshold=0, parameterKMax=0, parameterzeroThreshold=0.000001, inputSignal="barMSE", outputBoundaries="boundaries", outputLabels="labels", outputOnsets="onsets", cachingLevel=0, forceRefreshCache=False): """ Estimator computing the structure of a track based on salient points in the input signal the input signal should not be too noisy. It works best when the input signal is already averaged per beats or per downbeats Parameters ---------- diffThreshold (optional float): threshold setting the difference between the previous sample and the current one to label it as a segment. this difference is computed in term of diffThreshold * (mean difference between each sample) kMax (optional int): If you don't want to use a factor for the saillance detection, you can specify to return the k-most saillant points. ratioThreshold (optional float): thresold setting the ratio difference between two point to consider them saillant zeroThreshold (float): Indicating the threshold under which an amplitude should be considered as being zero. it's usefull to set the first segment where the difference between the samples is not big because the signal is rizing from silence. """ self.parameters = { "diffThreshold": Parameter(parameterDiffThreshold), "ratioThreshold": Parameter(parameterRatioThreshold), "kMax": Parameter(parameterKMax), "zeroThreshold": Parameter(parameterzeroThreshold) } raise DeprecationWarning() self.inputs = [inputSignal] self.outputs = [outputBoundaries, outputLabels, outputOnsets] self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache
def __init__(self, inputPath="path", outputSamples="samples", parameterSampleRate=None, cachingLevel=2, forceRefreshCache=False): self.inputs = [inputPath] self.outputs = [outputSamples] self.parameters = {"sampleRate": Parameter(parameterSampleRate)} self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache
def __init__( self, inputFeatures=["cqtAmplitudeCheckerboard"], inputGrid="strongBeats", outputPeriod="period", parameterDistanceMetric="RMS", parameterFeatureAggregation="quantitative", parameterPeriod=2, cachingLevel=2, forceRefreshCache=True ): #As long as there is no way of updating the cache when the input changes self.inputs = [inputFeatures, inputGrid] self.outputs = [outputPeriod] self.parameters = { "period": Parameter(parameterPeriod), "distanceMetric": Parameter(parameterDistanceMetric), "featureAggregation": Parameter(parameterFeatureAggregation) } self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache
def __init__(self, inputPath="path", outputClassification="vocals", outputPitch="vocalsMelody", parameterModel="Seg", cachingLevel=0, forceRefreshCache=False): self.inputs = [inputPath] self.outputs = [outputClassification, outputPitch] self.parameters = {"model": Parameter(parameterModel)} self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache
def __init__(self, inputSignal="cqtAmplitudeCheckerboardPeaks", inputGrid="period", outputSignal="cqtAmplitudeCheckerboardQuantized", parameterMaxThreshold=-1, cachingLevel=2, forceRefreshCache=False): self.inputs = [inputSignal, inputGrid] self.outputs = [outputSignal] self.parameters = {"maxThreshold": Parameter(parameterMaxThreshold)} self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache
def __init__( self, parameterAbsoluteTop=None, # Absolute number of peaks to select. Set to None to kepp all the peaks parameterClusterDistance=0, # The distance in seconds to cluster multiple features occuring at the same time. parameterMergeFunction=np.sum, # How the clustered peaks' values are merged parameterRelativeDistance=1, # Return peaks only within in the beginning % of the track parameterSalienceTreshold=0, # Return peaks preceding a segment having at least this quantity in the Salience feature parameterSalienceWindow=8, # the size of the window suceeding the peak to compute the salience inputPeaks=["cqtAmplitudeCheckerboardPeaks"], # The peaks filtered inputGrid="strongBeats", # The grid to compute the salience window and the duration of the track inputSalience=["cqtAmplitudeRMSE"], # The list of features used for the salience outputPeaks="selectedPeaks", # Name of the output outputNonSalient="nonSalientPeaks", cachingLevel=0, forceRefreshCache=True): #As long as there is no way of updating the cache when the input changes """ Estimator selecting peaks from multiple list of peaks. """ self.parameters = { "absoluteTop": Parameter(parameterAbsoluteTop), "clusterDistance": Parameter(parameterClusterDistance), "relativeDistance": Parameter(parameterRelativeDistance), "salienceTreshold": Parameter(parameterSalienceTreshold), "salienceWindow": Parameter(parameterSalienceWindow), "mergeFunction": Parameter(parameterMergeFunction) } self.inputs = [inputPeaks, inputGrid, inputSalience] self.outputs = [outputPeaks, outputNonSalient] self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache
def __init__(self, parameterSnapDistance=0.05, parameterTransitionLambda=300, parameterCorrectToActivation=True, inputPath="path", outputBeats="beats", outputdownbeats="downbeats", outputStrongBeats="strongBeats", outputTempo="tempo", cachingLevel=0, forceRefreshCache=False): self.parameters = { "snapDistance": Parameter(parameterSnapDistance), "transitionLambda": Parameter(parameterTransitionLambda), "correctToActivation": Parameter(parameterCorrectToActivation) } self.inputs = [inputPath] self.outputs = [ outputBeats, outputdownbeats, outputStrongBeats, outputTempo ] self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache
def __init__(self, parameterWindow="rectangular", parameterAggregation="rmse", parameterSteps=1, parameterPanning=0, inputSamples="samples", inputGrid="downbeats", output="RMSE", cachingLevel=0, forceRefreshCache=False): """ Create a window of the input signal at each grid tick parameterWindow: the name of the window function to apply: - rectangular: Only window currently implemented parameterAggregation: What to do to the values in the window - None - rmse - sum parameterPanning: How much do you shift, in ratio of the median distance between the grid ticks, the windows boundaries. Use a neagtive value (ie -0.25) to shift the windows 1/4 of the grid to the left. parameterSteps: TODO """ # parameterLength: TODO implement # parameterBands=[[20, 250], [250, 3000], [3000, 22000]], self.parameters = { "window": Parameter(parameterWindow), "aggregation": Parameter(parameterAggregation), "steps": Parameter(parameterSteps), "panning": Parameter(parameterPanning) } self.inputs = [inputSamples, inputGrid] self.outputs = [output] self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache
def __init__(self, parameterModel="CRNN_3", inputPath="path", outputKick="kick", outputSnare="snare", outputHihat="hihat", cachingLevel=0, forceRefreshCache=False): super().__init__() self.parameters = {"model": Parameter(parameterModel)} self.inputs = [inputPath] self.outputs = [outputKick, outputSnare, outputHihat] self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache
def __init__( self, # parameter_Mp_adaptive=28, # parameter_offset_thres=0.05, parameter_M_gaussian=16, parameter_m_embedded=3, parameter_k_nearest=0.04, parameter_bound_norm_feats=np.inf, inputSamples="normalizedBarMSE", outputNovelty="noveltyMSE", cachingLevel=2, forceRefreshCache=False): self.parameters = { # "Mp_adaptive": Parameter(parameter_Mp_adaptive), # "offset_thres": Parameter(parameter_offset_thres), "M_gaussian": Parameter(parameter_M_gaussian), "m_embedded": Parameter(parameter_m_embedded), "k_nearest": Parameter(parameter_k_nearest), "bound_norm_feats": Parameter(parameter_bound_norm_feats) } self.inputs = [inputSamples] self.outputs = [outputNovelty] self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache
def __init__(self, inputValues="samples", inputGrid="period", parameterIncludeBorders=True, outputPeaks="core", cachingLevel=0, forceRefreshCache=False): """Look at the rms of the signal for a segment and label it as a core if it's abov the rms of the full track """ self.parameters = { "includeBorders": Parameter(parameterIncludeBorders) } self.inputs = [inputValues, inputGrid] self.outputs = [outputPeaks] self.cachingLevel = cachingLevel self.forceRefreshCache = forceRefreshCache