}Kg  dZddlmZddlZddlmZddlmZddl m Z m Z m Z m Z mZddlmZdd lmZdd lmZmZmZmZmZmZmZdd lmZdd lmZmZgd Z eddddddddd dDdZ!eddddddddd dEdZ!edddddddd dFdZ!edddddddd dGdZ!edddddddddd dHdZ!edddddddddd dIdZ!eddddddddd dJdZ!eddddddddd dKdZ! dLddddddddddd dMd Z!edd! dNd"Z"edd! dO dPd#Z#dddd$ dQd%Z$edddd& dRd'Z%eddddd( dSd)Z%eddddd( dTd*Z%ddddd( dTd+Z%edd! dUd,Z&d-Z'edd! dVd.Z(edd/ dWd0Z)eddd1 dXd2Z)ddd1 dYd3Z)edddd4 dZd5Z*eddd6 d[d7Z*eddd6 d\d8Z*dddd4 d\d9Z*edddd4 dZd:Z+eddd6 d[d;Z+edddd4 d\d<Z+dddd4 d\d=Z+d]d>Z,d^d?Z-d^d@Z.dAddB d_dCZ/y)`a Sequential modeling =================== Sequence alignment ------------------ .. autosummary:: :toctree: generated/ dtw rqa Viterbi decoding ---------------- .. autosummary:: :toctree: generated/ viterbi viterbi_discriminative viterbi_binary Transition matrices ------------------- .. autosummary:: :toctree: generated/ transition_uniform transition_loop transition_cycle transition_local ) annotationsN)cdist)jit) pad_centerfill_off_diagonalis_positive_inttiny expand_to)ParameterError) get_window)AnyIterableListOptionalTupleUnionoverload)Literal) _WindowSpec _IntLike_co) dtwdtw_backtrackingrqaviterbiviterbi_discriminativeviterbi_binarytransition_uniformtransition_looptransition_cycletransition_local.)metricstep_sizes_sigma weights_add weights_mulsubseqglobal_constraintsband_rad return_stepsc yN XYr"r#r$r%r& backtrackr'r(r)s T/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/librosa/sequence.pyrr<c yr+r, Cr"r#r$r%r&r0r'r(r)s r1rrNr3)r"r#r$r%r&r'r(c yr+r,r-s r1rr_r2r3c yr+r,r5s r1rrqr7r3) r"r#r$r%r&r0r'r(r)c yr+r,r-s r1rrr2r3c yr+r,r5s r1rrr7r3)r"r#r$r%r&r0r'r(c yr+r,r-s r1rrr2r3c yr+r,r5s r1rrr7r3 euclideanFTg?r5c X tjddgddgddggtj} tjdtj} tj dtj}| | }|| }||}n|.tjt |tj}|.tj t |tj}| jtj|jtjtj| |f}tj| |f}tj||f}|J|J|Jtj|dkr tdt |t |k7r tdt |t |k7r td||| td ||| td d }d }|d }||Jtj|}tj|}tj|d d}tj|d d}|j|jdd fd}|j|jdd fd} t!|||}|r-|jd|jdkDr|j$}d }tj|}tj&|tjddggr*|jd|jdkDr td|dddfj)}|dddfj)}tjtj*|r td| r3|stj,|}t/|| tjtj |jtj||gztjz}|d|||f<|r|dddf|||df<tj|jtj0}d|dddf<d|dddf<t3||||||||\}}||d|df}||d|df}|r!|ratj4tj6|d r tdtj8|d ddf}t;||||}nCtj6|dr tdt;|||}|d dk7r tdtj<|t>}|rY|!||jd|jdkDs!|s|jd|jdkDrtj@|}||g}n|g}| r|jC|t |dkDr tE|S|dS#t"$r}td|d}~wwxYw)uRDynamic time warping (DTW). This function performs a DTW and path backtracking on two sequences. We follow the nomenclature and algorithmic approach as described in [#]_. .. [#] Meinard Mueller Fundamentals of Music Processing — Audio, Analysis, Algorithms, Applications Springer Verlag, ISBN: 978-3-319-21944-8, 2015. Parameters ---------- X : np.ndarray [shape=(..., K, N)] audio feature matrix (e.g., chroma features) If ``X`` has more than two dimensions (e.g., for multi-channel inputs), all leading dimensions are used when computing distance to ``Y``. Y : np.ndarray [shape=(..., K, M)] audio feature matrix (e.g., chroma features) C : np.ndarray [shape=(N, M)] Precomputed distance matrix. If supplied, X and Y must not be supplied and ``metric`` will be ignored. metric : str Identifier for the cost-function as documented in `scipy.spatial.distance.cdist()` step_sizes_sigma : np.ndarray [shape=[n, 2]] Specifies allowed step sizes as used by the dtw. weights_add : np.ndarray [shape=[n, ]] Additive weights to penalize certain step sizes. weights_mul : np.ndarray [shape=[n, ]] Multiplicative weights to penalize certain step sizes. subseq : bool Enable subsequence DTW, e.g., for retrieval tasks. backtrack : bool Enable backtracking in accumulated cost matrix. global_constraints : bool Applies global constraints to the cost matrix ``C`` (Sakoe-Chiba band). band_rad : float The Sakoe-Chiba band radius (1/2 of the width) will be ``int(radius*min(C.shape))``. return_steps : bool If true, the function returns ``steps``, the step matrix, containing the indices of the used steps from the cost accumulation step. Returns ------- D : np.ndarray [shape=(N, M)] accumulated cost matrix. D[N, M] is the total alignment cost. When doing subsequence DTW, D[N,:] indicates a matching function. wp : np.ndarray [shape=(N, 2)] Warping path with index pairs. Each row of the array contains an index pair (n, m). Only returned when ``backtrack`` is True. steps : np.ndarray [shape=(N, M)] Step matrix, containing the indices of the used steps from the cost accumulation step. Only returned when ``return_steps`` is True. Raises ------ ParameterError If you are doing diagonal matching and Y is shorter than X or if an incompatible combination of X, Y, and C are supplied. If your input dimensions are incompatible. If the cost matrix has NaN values. Examples -------- >>> import numpy as np >>> import matplotlib.pyplot as plt >>> y, sr = librosa.load(librosa.ex('brahms'), offset=10, duration=15) >>> X = librosa.feature.chroma_cens(y=y, sr=sr) >>> noise = np.random.rand(X.shape[0], 200) >>> Y = np.concatenate((noise, noise, X, noise), axis=1) >>> D, wp = librosa.sequence.dtw(X, Y, subseq=True) >>> fig, ax = plt.subplots(nrows=2, sharex=True) >>> img = librosa.display.specshow(D, x_axis='frames', y_axis='frames', ... ax=ax[0]) >>> ax[0].set(title='DTW cost', xlabel='Noisy sequence', ylabel='Target') >>> ax[0].plot(wp[:, 1], wp[:, 0], label='Optimal path', color='y') >>> ax[0].legend() >>> fig.colorbar(img, ax=ax[0]) >>> ax[1].plot(D[-1, :] / wp.shape[0]) >>> ax[1].set(xlim=[0, Y.shape[1]], ylim=[0, 2], ... title='Matching cost function') rrdtypeNz/step_sizes_sigma cannot contain negative valuesz7len(weights_add) must be equal to len(step_sizes_sigma)z7len(weights_mul) must be equal to len(step_sizes_sigma)z3If C is not supplied, both X and Y must be suppliedz3If C is supplied, both X and Y must not be suppliedFTF)order)r"zscipy.spatial.distance.cdist returned an error. Please provide your input in the form X.shape=(K, N) and Y.shape=(K, M). 1-dimensional sequences should be reshaped to X.shape=(1, N) and Y.shape=(1, M).zMFor diagonal matching: Y.shape[-1] >= X.shape[-11] (C.shape[1] >= C.shape[0])z"DTW cost matrix C has NaN values. )radiusvaluerrzRNo valid sub-sequence warping path could be constructed with the given step sizes.rCrCzVUnable to compute a full DTW warping path. You may want to try again with subseq=True.)#nparrayuint32zerosfloat64oneslenfillinf concatenateanyr atleast_2dswapaxesreshapeshaper ValueErrorT array_equalmaxisnancopyrint32__dtw_calc_accu_costallisinfargmin__dtw_backtrackingasarrayintfliplrappendtuple)r.r/r6r"r#r$r%r&r0r'r(r) default_stepsdefault_weights_adddefault_weights_mulc_is_transposedC_localexcmax_0max_1Dstepsstart_wpwp return_valuess r1rrsjHHq!fq!fq!f5RYYGM((1BJJ7''!2::6(  -K  -K  ((3'7#8 KK  ''#&6"7rzzJK   (  (>>=:J*KLnn&9;%GH nn&9;%GH   '' '  "" "  "" " vv"#NOO K 00VWW K 00VWWyai19RSS}!-1=RSSO Gy}.. MM!  MM!  KK2q ! KK2q ! IIqwwqz2&cI 2 IIqwwqz2&cI 2 a6*A qwwqzAGGAJ.A"O aA ~~&1a&(:;  QWWQZ )  QT " & & (E QT " & & (E vvbhhqkABB A!HBFF; "((E5>223bffA%u{{1~'9:;;q>A%u- BIIwqz71:&' gaj1nfF9Jgaj'!*56  AJ),7: : AJ),7: :  w>=:J*KL E#3VU CB ::b $$r3) gap_onset gap_extend knight_movescyr+r,simrrrr0s r1rrr3)rrrr0cyr+r,rs r1rrrr3cyr+r,rs r1rrrr3c|dkr td|dkr tdt||||\}}|rt||}||fS|S)uRecurrence quantification analysis (RQA) This function implements different forms of RQA as described by Serra, Serra, and Andrzejak (SSA). [#]_ These methods take as input a self- or cross-similarity matrix ``sim``, and calculate the value of path alignments by dynamic programming. Note that unlike dynamic time warping (`dtw`), alignment paths here are maximized, not minimized, so the input should measure similarity rather than distance. The simplest RQA method, denoted as `L` (SSA equation 3) and equivalent to the method described by Eckman, Kamphorst, and Ruelle [#]_, accumulates the length of diagonal paths with positive values in the input: - ``score[i, j] = score[i-1, j-1] + 1`` if ``sim[i, j] > 0`` - ``score[i, j] = 0`` otherwise. The second method, denoted as `S` (SSA equation 4), is similar to the first, but allows for "knight moves" (as in the chess piece) in addition to strict diagonal moves: - ``score[i, j] = max(score[i-1, j-1], score[i-2, j-1], score[i-1, j-2]) + 1`` if ``sim[i, j] > 0`` - ``score[i, j] = 0`` otherwise. The third method, denoted as `Q` (SSA equations 5 and 6) extends this by allowing gaps in the alignment that incur some cost, rather than a hard reset to 0 whenever ``sim[i, j] == 0``. Gaps are penalized by two additional parameters, ``gap_onset`` and ``gap_extend``, which are subtracted from the value of the alignment path every time a gap is introduced or extended (respectively). Note that setting ``gap_onset`` and ``gap_extend`` to `np.inf` recovers the second method, and disabling knight moves recovers the first. .. [#] Serrà, Joan, Xavier Serra, and Ralph G. Andrzejak. "Cross recurrence quantification for cover song identification." New Journal of Physics 11, no. 9 (2009): 093017. .. [#] Eckmann, J. P., S. Oliffson Kamphorst, and D. Ruelle. "Recurrence plots of dynamical systems." World Scientific Series on Nonlinear Science Series A 16 (1995): 441-446. Parameters ---------- sim : np.ndarray [shape=(N, M), non-negative] The similarity matrix to use as input. This can either be a recurrence matrix (self-similarity) or a cross-similarity matrix between two sequences. gap_onset : float > 0 Penalty for introducing a gap to an alignment sequence gap_extend : float > 0 Penalty for extending a gap in an alignment sequence knight_moves : bool If ``True`` (default), allow for "knight moves" in the alignment, e.g., ``(n, m) => (n + 1, m + 2)`` or ``(n + 2, m + 1)``. If ``False``, only allow for diagonal moves ``(n, m) => (n + 1, m + 1)``. backtrack : bool If ``True``, return the alignment path. If ``False``, only return the score matrix. Returns ------- score : np.ndarray [shape=(N, M)] The alignment score matrix. ``score[n, m]`` is the cumulative value of the best alignment sequence ending in frames ``n`` and ``m``. path : np.ndarray [shape=(k, 2)] (optional) If ``backtrack=True``, ``path`` contains a list of pairs of aligned frames in the best alignment sequence. ``path[i] = [n, m]`` indicates that row ``n`` aligns to column ``m``. See Also -------- librosa.segment.recurrence_matrix librosa.segment.cross_similarity dtw Examples -------- Simple diagonal path enhancement (L-mode) >>> import numpy as np >>> import matplotlib.pyplot as plt >>> y, sr = librosa.load(librosa.ex('nutcracker'), duration=30) >>> chroma = librosa.feature.chroma_cqt(y=y, sr=sr) >>> # Use time-delay embedding to reduce noise >>> chroma_stack = librosa.feature.stack_memory(chroma, n_steps=10, delay=3) >>> # Build recurrence, suppress self-loops within 1 second >>> rec = librosa.segment.recurrence_matrix(chroma_stack, width=43, ... mode='affinity', ... metric='cosine') >>> # using infinite cost for gaps enforces strict path continuation >>> L_score, L_path = librosa.sequence.rqa(rec, ... gap_onset=np.inf, ... gap_extend=np.inf, ... knight_moves=False) >>> fig, ax = plt.subplots(ncols=2) >>> librosa.display.specshow(rec, x_axis='frames', y_axis='frames', ax=ax[0]) >>> ax[0].set(title='Recurrence matrix') >>> librosa.display.specshow(L_score, x_axis='frames', y_axis='frames', ax=ax[1]) >>> ax[1].set(title='Alignment score matrix') >>> ax[1].plot(L_path[:, 1], L_path[:, 0], label='Optimal path', color='c') >>> ax[1].legend() >>> ax[1].label_outer() Full alignment using gaps and knight moves >>> # New gaps cost 5, extending old gaps cost 10 for each step >>> score, path = librosa.sequence.rqa(rec, gap_onset=5, gap_extend=10) >>> fig, ax = plt.subplots(ncols=2, sharex=True, sharey=True) >>> librosa.display.specshow(rec, x_axis='frames', y_axis='frames', ax=ax[0]) >>> ax[0].set(title='Recurrence matrix') >>> librosa.display.specshow(score, x_axis='frames', y_axis='frames', ax=ax[1]) >>> ax[1].set(title='Alignment score matrix') >>> ax[1].plot(path[:, 1], path[:, 0], label='Optimal path', color='c') >>> ax[1].legend() >>> ax[1].label_outer() rz&gap_onset={} must be strictly positivez'gap_extend={} must be strictly positive)r __rqa_dp__rqa_backtrack)rrrrr0scorepointerspaths r1rrs_N1}EFFA~FGGsIz<HOE8uh/d{ Lr3c | tj|j|j}tj|jtj}tjd}tjd}tjd}|rd} d} nd} d} |dddf|dddf<|dddf|dddf<t |jdD]} || dfrd|| df<d|| df<t |jdD]} |d| frd|d| f<d|d| f<|d dkDr|d |d z|d <d|d <n:|d dkD} t d|d | |zz | |zz |d <|d dkDrd|d <nd|d <d} t d|jdD]} || dz | dz f|| dz | dz ff|dd|| dz | dz f|| dz | dz ff|dd|dkD}|| | fdkDr5tj|d| || | f<||| | f|| | fz|| | f<|d| |d| |zz |d| |zz |d| tj|d| || | f<t d||| | f|| | f<|| | fdk(sd|| | f<d} t d|jdD]} || dz | dz f|| dz | dz ff|dd|| dz | dz f|| dz | dz ff|dd|dkD}|| | fdkDr5tj|d| || | f<||| | f|| | fz|| | f<|d| |d| |zz |d| |zz |d| tj|d| || | f<t d||| | f|| | f<|| | fdk(sd|| | f<t d|jdD]} t d|jdD]} || dz | dz f|| dz | dz f|| dz | dz ff|dd|| dz | dz f|| dz | dz f|| dz | dz ff|dd|dkD}|| | fdkDr5tj|d| || | f<||| | f|| | fz|| | f<|d| |d| |zz |d| |zz |d| tj|d| || | f<t d||| | f|| | f<|| | fdk(sd|| | f<||fS) z&RQA dynamic programming implementationr@rBrIrrNrC)rrrH)rKrNrYrAint8r|r]argmax)rrrknightrr0 sim_values score_valuesvec init_limitlimitijlinkt_valuess r1rr~sp HHSYYcii 0E"''2I!J88A;L ((1+C   ad)E!Q$Kad)E!Q$K399Q<  q!t9 IadO IadO ! 399Q<  q!t9 IadO IadO ! 4y1}DkCI-d  $4y1}!U4[DI+==$*@TTUd ;?IdO IdO A 1ciil #"1q5!a%<0%Aq1u 2EF Sbq1ua!e|,c!a%Q,.?@ 3B> q!t9q= ii [j(ABIadO&yA7#ad)CE!Q$K[j);J')34[j))Z78    !iiKZ(89IadOaYq!t_!56E!Q$KQT{a"$ !Q$%$* A 1ciil #"1q5!a%<0%Aq1u 2EF Sbq1ua!e|,c!a%Q,.?@ 3B> q!t9q= ii [j(ABIadO&yA7#ad)CE!Q$K[j);J')34[j))Z78    !iiKZ(89IadOaYq!t_!56E!Q$KQT{a"$ !Q$'$,1ciil #q#))A,'Aa!eQUl#a!eQUl#a!eQUl#LO !QA.AE1q5L0A3q1uaRSe|CTUJqM!A~H1a4y1} #%))L%,@"A !Q$ 1a41C1I=ad !%(v&23 %((J67FU #%))CK"8 !Q$!!S1a4%9:ad A;!#&(IadO?($D ) r3cgd}ttjtj||j}g} |t |}|dk(rnF|j d||dk(rn.tt|Dcgc]}|||||z}}Z|s%tjdtjStj|tjScc}w)zvRQA path backtracking Given the score matrix and backtracking index array, reconstruct the optimal path. )rJ)rCr)rrCrCrr)rrIr@) listrK unravel_indexrrYrjinsertr|rQemptyuintrf)rroffsetsidxrbt_index_s r1rrs-G r % 0%++> ?CD E#J' r>  As r> 7j. Each row must sum to 1. p_init : np.ndarray [shape=(n_states,)] Optional: initial state distribution. If not provided, a uniform distribution is assumed. return_logp : bool If ``True``, return the log-likelihood of the state sequence. Returns ------- Either ``states`` or ``(states, logp)``: states : np.ndarray [shape=(..., n_steps,)] The most likely state sequence. If ``prob`` contains multiple channels of input, then each channel is decoded independently. logp : scalar [float] or np.ndarray If ``return_logp=True``, the log probability of ``states`` given the observations. See Also -------- viterbi_discriminative : Viterbi decoding from state likelihoods Examples -------- Example from https://en.wikipedia.org/wiki/Viterbi_algorithm#Example In this example, we have two states ``healthy`` and ``fever``, with initial probabilities 60% and 40%. We have three observation possibilities: ``normal``, ``cold``, and ``dizzy``, whose probabilities given each state are: ``healthy => {normal: 50%, cold: 40%, dizzy: 10%}`` and ``fever => {normal: 10%, cold: 30%, dizzy: 60%}`` Finally, we have transition probabilities: ``healthy => healthy (70%)`` and ``fever => fever (60%)``. Over three days, we observe the sequence ``[normal, cold, dizzy]``, and wish to know the maximum likelihood assignment of states for the corresponding days, which we compute with the Viterbi algorithm below. >>> p_init = np.array([0.6, 0.4]) >>> p_emit = np.array([[0.5, 0.4, 0.1], ... [0.1, 0.3, 0.6]]) >>> p_trans = np.array([[0.7, 0.3], [0.4, 0.6]]) >>> path, logp = librosa.sequence.viterbi(p_emit, p_trans, p_init=p_init, ... return_logp=True) >>> print(logp, path) -4.19173690823075 [0 0 1] rNtransition.shape=, must be (n_states, n_states)=rraxisIInvalid transition matrix: must be non-negative and sum to 1 on each row.z4Invalid probability values: must be between 0 and 1.?+Invalid initial state distribution: p_init=cTt|j\}}|j|fSr+rr[lp_staterrrs r1_helperzviterbi.._helper'i< xx~r3rI(s,t)->(t),(1)otypes signature.r)rYr rKrUallclosesumr rrRlogndim vectorizerrO)rrrrrrepsilonrrstatesr __viterbirrs @@r1rrs` 23HgHh// 0 012$$,h$6#7 9   vvj1nR[[Q1G%K (   vvdQh266$(+STT4jG ~(# C(N# vz{{6::<+ <j. Each row must sum to 1. p_state : np.ndarray [shape=(n_states,)] Optional: marginal probability distribution over states, must be non-negative and sum to 1. If not provided, a uniform distribution is assumed. p_init : np.ndarray [shape=(n_states,)] Optional: initial state distribution. If not provided, it is assumed to be uniform. return_logp : bool If ``True``, return the log-likelihood of the state sequence. Returns ------- Either ``states`` or ``(states, logp)``: states : np.ndarray [shape=(..., n_steps,)] The most likely state sequence. If ``prob`` contains multiple input channels, then each channel is decoded independently. logp : scalar [float] or np.ndarray If ``return_logp=True``, the (unnormalized) log probability of ``states`` given the observations. See Also -------- viterbi : Viterbi decoding from observation likelihoods viterbi_binary : Viterbi decoding for multi-label, conditional state likelihoods Examples -------- This example constructs a simple, template-based discriminative chord estimator, using CENS chroma as input features. .. note:: this chord model is not accurate enough to use in practice. It is only intended to demonstrate how to use discriminative Viterbi decoding. >>> # Create templates for major, minor, and no-chord qualities >>> maj_template = np.array([1,0,0, 0,1,0, 0,1,0, 0,0,0]) >>> min_template = np.array([1,0,0, 1,0,0, 0,1,0, 0,0,0]) >>> N_template = np.array([1,1,1, 1,1,1, 1,1,1, 1,1,1.]) / 4. >>> # Generate the weighting matrix that maps chroma to labels >>> weights = np.zeros((25, 12), dtype=float) >>> labels = ['C:maj', 'C#:maj', 'D:maj', 'D#:maj', 'E:maj', 'F:maj', ... 'F#:maj', 'G:maj', 'G#:maj', 'A:maj', 'A#:maj', 'B:maj', ... 'C:min', 'C#:min', 'D:min', 'D#:min', 'E:min', 'F:min', ... 'F#:min', 'G:min', 'G#:min', 'A:min', 'A#:min', 'B:min', ... 'N'] >>> for c in range(12): ... weights[c, :] = np.roll(maj_template, c) # c:maj ... weights[c + 12, :] = np.roll(min_template, c) # c:min >>> weights[-1] = N_template # the last row is the no-chord class >>> # Make a self-loop transition matrix over 25 states >>> trans = librosa.sequence.transition_loop(25, 0.9) >>> # Load in audio and make features >>> y, sr = librosa.load(librosa.ex('nutcracker'), duration=15) >>> # Suppress percussive elements >>> y = librosa.effects.harmonic(y, margin=4) >>> chroma = librosa.feature.chroma_cqt(y=y, sr=sr) >>> # Map chroma (observations) to class (state) likelihoods >>> probs = np.exp(weights.dot(chroma)) # P[class | chroma] ~= exp(template' chroma) >>> probs /= probs.sum(axis=0, keepdims=True) # probabilities must sum to 1 in each column >>> # Compute independent frame-wise estimates >>> chords_ind = np.argmax(probs, axis=0) >>> # And viterbi estimates >>> chords_vit = librosa.sequence.viterbi_discriminative(probs, trans) >>> # Plot the features and prediction map >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(nrows=2) >>> librosa.display.specshow(chroma, x_axis='time', y_axis='chroma', ax=ax[0]) >>> librosa.display.specshow(weights, x_axis='chroma', ax=ax[1]) >>> ax[1].set(yticks=np.arange(25) + 0.5, yticklabels=labels, ylabel='Chord') >>> # And plot the results >>> fig, ax = plt.subplots() >>> librosa.display.specshow(probs, x_axis='time', cmap='gray', ax=ax) >>> times = librosa.times_like(chords_vit) >>> ax.scatter(times, chords_ind + 0.25, color='lime', alpha=0.5, marker='+', ... s=15, label='Independent') >>> ax.scatter(times, chords_vit - 0.25, color='deeppink', alpha=0.5, marker='o', ... s=15, label='Viterbi') >>> ax.set(yticks=np.unique(chords_vit), ... yticklabels=[labels[i] for i in np.unique(chords_vit)]) >>> ax.legend() rNrrrrrrzIInvalid probability values: each column must sum to 1 and be non-negativerzMMarginal distribution p_state must have shape (n_states,). Got p_state.shape=rCz-Invalid marginal state distribution: p_state=r)raxescTt|j\}}|j|fSr+rrs r1rz'viterbi_discriminative.._helper rr3rIrrr)rYr rKrUrrr rrRrr rrrrO)rrrrrrrr log_marginalrrrrrrrs @@r1rrSsv 23HgHh// 0 012$$,h$6#7 9   vvj1nR[[Q1G%K (   vvdQhr{{4888+rr3ctj|}|jdd\}}|jdk(rtj||ddf}n-|j|ddfk7rt d|jd|tj |dks&tj |jd ds t d tj |dkstj |dkDr t d |'tj|}|jd ntj|}|J|j|fk7s0tj |dkstj |dkDrt d||'tj|}|jd ntj|}|J|j|fk7s0tj |dkstj |dkDrt d|t|jdd}tj|||gztj}tj||gz} tj|d|gz} tjd} tjd} t|D]r} d|d| ddfz | ddddf<|d| ddf| ddddf<d|| z | d<|| | d<d|| z | d<|| | d<t| || | | d\|d| ddf<| d| f<t|r|| fS|S)a+Viterbi decoding from binary (multi-label), discriminative state predictions. Given a sequence of conditional state predictions ``prob[s, t]``, indicating the conditional likelihood of state ``s`` being active conditional on observation at time ``t``, and a 2*2 transition matrix ``transition`` which encodes the conditional probability of moving from state ``s`` to state ``~s`` (not-``s``), the Viterbi algorithm computes the most likely sequence of states from the observations. This function differs from `viterbi_discriminative` in that it does not assume the states to be mutually exclusive. `viterbi_binary` is implemented by transforming the multi-label decoding problem to a collection of binary Viterbi problems (one for each *state* or label). The output is a binary matrix ``states[s, t]`` indicating whether each state ``s`` is active at time ``t``. Like `viterbi_discriminative`, the probabilities of the optimal state sequences are not normalized here. If using the `return_logp=True` option (see below), be aware that the "probabilities" may not sum to (and may exceed) 1. Parameters ---------- prob : np.ndarray [shape=(..., n_steps,) or (..., n_states, n_steps)], non-negative ``prob[s, t]`` is the probability of state ``s`` being active conditional on the observation at time ``t``. Must be non-negative and less than 1. If ``prob`` is 1-dimensional, it is expanded to shape ``(1, n_steps)``. If ``prob`` contains multiple input channels, then each channel is decoded independently. transition : np.ndarray [shape=(2, 2) or (n_states, 2, 2)], non-negative If 2-dimensional, the same transition matrix is applied to each sub-problem. ``transition[0, i]`` is the probability of the state going from inactive to ``i``, ``transition[1, i]`` is the probability of the state going from active to ``i``. Each row must sum to 1. If 3-dimensional, ``transition[s]`` is interpreted as the 2x2 transition matrix for state label ``s``. p_state : np.ndarray [shape=(n_states,)] Optional: marginal probability for each state (between [0,1]). If not provided, a uniform distribution (0.5 for each state) is assumed. p_init : np.ndarray [shape=(n_states,)] Optional: initial state distribution. If not provided, it is assumed to be uniform. return_logp : bool If ``True``, return the (unnormalized) log-likelihood of the state sequences. Returns ------- Either ``states`` or ``(states, logp)``: states : np.ndarray [shape=(..., n_states, n_steps)] The most likely state sequence. logp : np.ndarray [shape=(..., n_states,)] If ``return_logp=True``, the (unnormalized) log probability of each state activation sequence ``states`` See Also -------- viterbi : Viterbi decoding from observation likelihoods viterbi_discriminative : Viterbi decoding for discriminative (mutually exclusive) state predictions Examples -------- In this example, we have a sequence of binary state likelihoods that we want to de-noise under the assumption that state changes are relatively uncommon. Positive predictions should only be retained if they persist for multiple steps, and any transient predictions should be considered as errors. This use case arises frequently in problems such as instrument recognition, where state activations tend to be stable over time, but subject to abrupt changes (e.g., when an instrument joins the mix). We assume that the 0 state has a self-transition probability of 90%, and the 1 state has a self-transition probability of 70%. We assume the marginal and initial probability of either state is 50%. >>> trans = np.array([[0.9, 0.1], [0.3, 0.7]]) >>> prob = np.array([0.1, 0.7, 0.4, 0.3, 0.8, 0.9, 0.8, 0.2, 0.6, 0.3]) >>> librosa.sequence.viterbi_binary(prob, trans, p_state=0.5, p_init=0.5) array([[0, 0, 0, 0, 1, 1, 1, 0, 0, 0]]) rN)rIrIrrIrz%, must be (2, 2) or (n_states, 2, 2)=rrCrrz7Invalid probability values: prob must be between [0, 1]g?z.Invalid marginal state distributions: p_state=z,Invalid initial state distributions: p_init=r@.Tr)rKrVrYtiler rUrrrrR atleast_1drrr|r)rrrrrrr shape_prefixrr prob_binaryp_state_binary p_init_binaryrs r1rrJs2~ == D 23Hg6!WWZ(Aq)9:   h1- - 0 012 (z +   vvj1nR[[R1H!%L (   vvdQh266$(+VWW((8$ S--(   }} #rvvgk':bffWq[>QMgYWXX ~(# Cv&    ||{"bffVaZ&8BFF6A: 0 The number of states Returns ------- transition : np.ndarray [shape=(n_states, n_states)] ``transition[i, j] = 1./n_states`` Examples -------- >>> librosa.sequence.transition_uniform(3) array([[0.333, 0.333, 0.333], [0.333, 0.333, 0.333], [0.333, 0.333, 0.333]]) n_states=z must be a positive integerr@r)r r rKrrOrR)rrs r1rrsP( 8 $y 2MNOO8X.bjjAJOOC(N# r3c6t|r|dkDstd|dtj||ftj}tj |tj}|j dk(rtj||}|j|fk7rtd|d|tj|dkstj|dkDrtd|dt|D]\}}d |z |dz z ||<||||f<|S) aConstruct a self-loop transition matrix over ``n_states``. The transition matrix will have the following properties: - ``transition[i, i] = p`` for all ``i`` - ``transition[i, j] = (1 - p) / (n_states - 1)`` for all ``j != i`` This type of transition matrix is appropriate when states tend to be locally stable, and there is no additional structure between different states. This is primarily useful for de-noising frame-wise predictions. Parameters ---------- n_states : int > 1 The number of states prob : float in [0, 1] or iterable, length=n_states If a scalar, this is the probability of a self-transition. If a vector of length ``n_states``, ``p[i]`` is the probability of self-transition in state ``i`` Returns ------- transition : np.ndarray [shape=(n_states, n_states)] The transition matrix Examples -------- >>> librosa.sequence.transition_loop(3, 0.5) array([[0.5 , 0.25, 0.25], [0.25, 0.5 , 0.25], [0.25, 0.25, 0.5 ]]) >>> librosa.sequence.transition_loop(3, [0.8, 0.5, 0.25]) array([[0.8 , 0.1 , 0.1 ], [0.25 , 0.5 , 0.25 ], [0.375, 0.375, 0.25 ]]) rr must be a positive integer > 1r@rprob=$ must have length equal to n_states=% must have values in the range [0, 1]r) r r rKrrOrfrrrYrU enumeraterrrrprob_is r1rrsN H %8a<y 2QRSS8X.bjjAJ ::d"** -D yyA~wwtX& zzh[ D6=hZ H   vvdQh266$(+uTF*OPQQt_ 6v(Q,7 1 ! 1a4% r3c\t|r|dkDstd|dtj||ftj}tj |tj}|j dk(rtj||}|j|fk7rtd|d|tj|dkstj|dkDrtd|dt|D]-\}}d |z ||tj|dz|f<||||f</|S) aTConstruct a cyclic transition matrix over ``n_states``. The transition matrix will have the following properties: - ``transition[i, i] = p`` - ``transition[i, i + 1] = (1 - p)`` This type of transition matrix is appropriate for state spaces with cyclical structure, such as metrical position within a bar. For example, a song in 4/4 time has state transitions of the form 1->{1, 2}, 2->{2, 3}, 3->{3, 4}, 4->{4, 1}. Parameters ---------- n_states : int > 1 The number of states prob : float in [0, 1] or iterable, length=n_states If a scalar, this is the probability of a self-transition. If a vector of length ``n_states``, ``p[i]`` is the probability of self-transition in state ``i`` Returns ------- transition : np.ndarray [shape=(n_states, n_states)] The transition matrix Examples -------- >>> librosa.sequence.transition_cycle(4, 0.9) array([[0.9, 0.1, 0. , 0. ], [0. , 0.9, 0.1, 0. ], [0. , 0. , 0.9, 0.1], [0.1, 0. , 0. , 0.9]]) rrrr@rrrrr) r r rKrNrOrfrrrYrUrmodrs r1r r QsL H %(Q,y 2QRSS8X.bjjAJ ::d"** -D yyA~wwtX& zzh[ D6=hZ H   vvdQh266$(+uTF*OPQQt_ 614v 1bffQUH--.! 1a4% r3triangle)windowwrapc t|r|dkDstd|dtj|t}|j dk(rtj ||}|j|fk7rtd|d|tj|dkrtd|dtj||ftj}t|D]q\}}tt||d | }tj||d z|zdz}|s-d|t|||d zzdzd d|d t!d||d zz |||<s||j#ddz}|S)aJ Construct a localized transition matrix. The transition matrix will have the following properties: - ``transition[i, j] = 0`` if ``|i - j| > width`` - ``transition[i, i]`` is maximal - ``transition[i, i - width//2 : i + width//2]`` has shape ``window`` This type of transition matrix is appropriate for state spaces that discretely approximate continuous variables, such as in fundamental frequency estimation. Parameters ---------- n_states : int > 1 The number of states width : int >= 1 or iterable The maximum number of states to treat as "local". If iterable, it should have length equal to ``n_states``, and specify the width independently for each state. window : str, callable, or window specification The window function to determine the shape of the "local" distribution. Any window specification supported by `filters.get_window` will work here. .. note:: Certain windows (e.g., 'hann') are identically 0 at the boundaries, so and effectively have ``width-2`` non-zero values. You may have to expand ``width`` to get the desired behavior. wrap : bool If ``True``, then state locality ``|i - j|`` is computed modulo ``n_states``. If ``False`` (default), then locality is absolute. See Also -------- librosa.filters.get_window Returns ------- transition : np.ndarray [shape=(n_states, n_states)] The transition matrix Examples -------- Triangular distributions with and without wrapping >>> librosa.sequence.transition_local(5, 3, window='triangle', wrap=False) array([[0.667, 0.333, 0. , 0. , 0. ], [0.25 , 0.5 , 0.25 , 0. , 0. ], [0. , 0.25 , 0.5 , 0.25 , 0. ], [0. , 0. , 0.25 , 0.5 , 0.25 ], [0. , 0. , 0. , 0.333, 0.667]]) >>> librosa.sequence.transition_local(5, 3, window='triangle', wrap=True) array([[0.5 , 0.25, 0. , 0. , 0.25], [0.25, 0.5 , 0.25, 0. , 0. ], [0. , 0.25, 0.5 , 0.25, 0. ], [0. , 0. , 0.25, 0.5 , 0.25], [0.25, 0. , 0. , 0.25, 0.5 ]]) Uniform local distributions with variable widths and no wrapping >>> librosa.sequence.transition_local(5, [1, 2, 3, 3, 1], window='ones', wrap=False) array([[1. , 0. , 0. , 0. , 0. ], [0.5 , 0.5 , 0. , 0. , 0. ], [0. , 0.333, 0.333, 0.333, 0. ], [0. , 0. , 0.333, 0.333, 0.333], [0. , 0. , 0. , 0. , 1. ]]) rrrr@rzwidth=rz must be at least 1F)fftbins)sizerINT)rkeepdims)r r rKrfrgrrrYrUrNrOrrr rollrr]r)rwidthrrrrwidth_i trans_rows r1r!r!sv\ H %(Q,y 2QRSS JJuC (E zzQx( {{xk!UG?z J   vveaiveW,?@AA8X.bjjAJ & 7 vw 6X GGIx1}q'81'<= ?@Ic(A1 $4q$89; <45I0Aq7a</0 1! 1 '*..a$.77J r3)r. np.ndarrayr/rr"strr#Optional[np.ndarray]r$rr%rr&boolr0Literal[False]r'rr(floatr)rreturnr)r6rr"rr#rr$rr%rr&rr0rr'rr(rr)rrr)r.rr/rr"rr#rr$rr%rr&rr0rr'rr(rr) Literal[True]rTuple[np.ndarray, np.ndarray])r6rr"rr#rr$rr%rr&rr0rr'rr(rr)rrr)r.rr/rr"rr#rr$rr%rr&rr0rr'rr(rr)rrr)r6rr"rr#rr$rr%rr&rr0rr'rr(rr)rrr)r.rr/rr"rr#rr$rr%rr&rr0rr'rr(rr)rr)Tuple[np.ndarray, np.ndarray, np.ndarray])r6rr"rr#rr$rr%rr&rr0rr'rr(rr)rrr)NN)r.rr/rr6rr"rr#rr$rr%rr&rr0rr'rr(rr)rrz[Union[np.ndarray, Tuple[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray, np.ndarray]])r6rrsrrtrr#rr%rr$rrqrgrrrgrrr+) rtrr#rr&rruz Optional[int]rzList[Tuple[int, int]]) rtrr#rr&rruz%Optional[Union[int, np.integer[Any]]]rr) rrrrrrrrr0rrr) rrrrrrrrr0rrr) rrrrrrrrr0rr0Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]) rrrrrrrrrr)rrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrrrr) rrrrrrrrrrrr) rrrrrrrrrrrr)rrgrr)rrgrzUnion[float, Iterable[float]]rr) rrgr zUnion[int, Iterable[int]]rrrrrr)0__doc__ __future__rnumpyrKscipy.spatial.distancernumbarutilrrr r r util.exceptionsr filtersr typingrrrrrrrtyping_extensionsr_typingrr__all__rrarerrrrrrrrrrr r!r,r3r1r%s >#(QQ+HHH%-  -0(+(+"#&   +  & & ! " -0(+(+"#&    +  &  &      !      -0(+(+"   +  & &  # " -0(+(+"    +  &  &        #     -0(+(+""#&   +  & & !# " -0(+(+""#&    +  &  &      ! #     -0(+(+""   +  & &  / " -0(+(+""    +  &  &        /   "#"u #-1(,(,$u u u  u  u + u &u &u  u u u u u u p d$EEE E! E  E  E E E#E EPd$  A A A A  A  A AN.237 3% 3%+3%  3% 1 3%  3%l          "       #         6  S SS S  S  S6Sld$V V %V38VBFV"V Vr0+fd$<<%/<=G<"< <~ $'   !    #   $'"%   !      $( K KK ! K  K 6 K\ %(#&"%  "  !     %(#&  "  !   #  %(#&  "  !   6 %)#' P PP" P ! P  P6Pf %(#&"%  "  !     %(#&  "  !   #  %(#&  "  !   6 %)#' g gg" g ! g  g6gT8>B=H% pp $p  p  p  pr3