:jFuddZddlZddlZddlZddlZddlZddlmZddlm Z m Z m Z m Z m Z mZddlmZddlZddlZddlmZddlmZmZmZmZddlmZdd lmZdd lm Z dd l!m"Z"m#Z#m$Z$m%Z%m&Z&dd l'm(Z(dd l)m*Z*ddl+m,Z,m-Z-ddl.m/Z/ddl0m1Z1m2Z2dde3fdZ4eGddZ5Gdde$eZ6y)zSpeaker diarization pipelinesN)Path)CallableMappingOptionalTextUnionAny) dataclass) rearrange)Audio InferenceModelPipeline) AudioFile) Clustering)PretrainedSpeakerEmbedding) PipelineModel PipelinePLDASpeakerDiarizationMixin get_modelget_plda)set_num_speakers)binarize) AnnotationSlidingWindowFeature)GreedyDiarizationErrorRate) ParamDictUniform batch_sizecJt|g|z}tj|d|iS)zBatchify iterable fillvalue)iter itertools zip_longest)iterablerr!argss /home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/pyannote/audio/pipelines/speaker_diarization.pybatchifyr(8s+ N j (D  $ <) <<c`eZdZUeed<eed<dZejdzed<dee e ffdZ y) DiarizeOutputspeaker_diarizationexclusive_speaker_diarizationNspeaker_embeddingsreturncg}|jjdD]C\}}}|jt|jdt|j d|dEg}|j jdD]C\}}}|jt|jdt|j d|dE||dS)aSerialize diarization output Example ------- { 'diarization': [{ 'start': 6.665, 'end': 7.165, 'speaker': 'SPEAKER_00'}, ...], 'exclusive_diarization': [{ 'start': 6.665, 'end': 7.165, 'speaker': 'SPEAKER_00'}, ...], } T) yield_label)startendspeaker) diarizationexclusive_diarization)r, itertracksappendroundr3r4r-)selfr6 speech_turn_r5r7s r' serializezDiarizeOutput.serializeNs& '+'?'?'J'J(K(  #KG   ";#4#4a8 !4&  !#'+'I'I'T'T(U(  #KG " ( (";#4#4a8 !4&  '%:  r)) __name__ __module__ __qualname__r__annotations__r.npndarraydictstrr r>r)r'r+r+?s<$#$.- -1 T)0. 4S>. r)r+ceZdZdZddddddddddddd d d d d d f d eded ededededede de de e de e d fde ee d fffd Zede fdZej$de fdZdZdZedZd,defdZ d-deded e efd!Zd"ed#ej6d$edefd%Z d.d&ed'e e d(e e d)e e d e edeezf d*Z de!fd+Z"xZ#S)/SpeakerDiarizationa Speaker diarization pipeline Parameters ---------- legacy : bool, optional Return only the diarization output. Defaults to return the full output with diarization, exclusive diarization, and speaker embeddings. segmentation : Model, str, or dict, optional Pretrained segmentation model. See pyannote.audio.pipelines.utils.get_model for supported format. segmentation_step: float, optional The segmentation model is applied on a window sliding over the whole audio file. `segmentation_step` controls the step of this window, provided as a ratio of its duration. Defaults to 0.1 (i.e. 90% overlap between two consecuive windows). embedding : Model, str, or dict, optional Pretrained embedding model. See pyannote.audio.pipelines.utils.get_model for supported format. embedding_exclude_overlap : bool, optional Exclude overlapping speech regions when extracting embeddings. Defaults (False) to use the whole speech. plda : PLDA, str, or dict, optional Pretrained PLDA. See pyannote.audio.pipelines.utils.get_plda for supported format. clustering : str, optional Clustering algorithm. See pyannote.audio.pipelines.clustering.Clustering for available options. segmentation_batch_size : int, optional Batch size used for speaker segmentation. Defaults to 1. embedding_batch_size : int, optional Batch size used for speaker embedding. Defaults to 1. der_variant : dict, optional Optimize for a variant of diarization error rate. Defaults to {"collar": 0.0, "skip_overlap": False}. This is used in `get_metric` when instantiating the metric: GreedyDiarizationErrorRate(**der_variant). token : str or bool, optional Huggingface token to be used for downloading from Huggingface hub. cache_dir: Path or str, optional Path to the folder where files downloaded from Huggingface hub are stored. Usage ----- # process audio file >>> output = pipeline("/path/to/audio.wav") # print diarization >>> assert isinstance(output.speaker_diarization, pyannote.core.Annotation) >>> for turn, speaker in output.speaker_diarization: ... print(f"start={turn.start:.1f}s stop={turn.end:.1f}s speaker_{speaker}") # get one speaker embedding per speaker >>> assert isinstance(output.speaker_embeddings, np.ndarray) >>> for s, speaker in enumerate(output.speaker_diarization.labels()): ... # output.speaker_embeddings[s] is the embedding of speaker `speaker` # exclusive diarization is the same as diarization except # that it does not contain overlapping speech segments >>> assert isinstance(output.exclusive_speaker_diarization, pyannote.core.Annotation) # force exactly 4 speakers >>> output = pipeline("/path/to/audio.wav", num_speakers=4) # force between 2 and 10 speakers >>> output = pipeline("/path/to/audio.wav", min_speakers=2, max_speakers=10) Fz(pyannote/speaker-diarization-community-1 segmentation) checkpoint subfolder皙? embeddingplda VBxClusteringNlegacysegmentation_stepembedding_exclude_overlap clusteringembedding_batch_sizesegmentation_batch_size der_varianttoken cache_dirc nt|||_||_t || | } ||_||_||_||_||_ t|| | |_ ||_ | xsddd|_ | jj}t!| ||j |zd| |_|j"j$jj&rt)t+dd|_n&t)t+d d t+dd |_|jd k(rd }nYt/|j | | |_t3|j0j4d|_|j0j8} t:|}|jdk(r#|jG|j||_$n|jG||_$|jHjJ|_&y#t<$r6t?ddjAtCt:jDdwxYw)N)rYrZF)collar skip_overlapT)durationstepskip_aggregationr?)min_duration_offrMg?) thresholdrcOracleClusteringnot_applicabledownmix) sample_ratemonozclustering must be one of [, ]rP)metric)'super__init__rRsegmentation_modelrrSrNrVrTrOr_plda klusteringrXspecificationsr_r _segmentationmodelpowersetrrrJr _embeddingr rh_audiorlrKeyError ValueErrorjoinlist __members__valuerUexpects_num_clusters_expects_num_speakers)r;rRrJrSrNrTrOrUrVrWrXrYrZrtsegmentation_durationrl Klustering __class__s r'rnzSpeakerDiarization.__init__s0  ". UiP!2"$8!)B& d%9E $&PS%*P % 4 4 = =& *''*??!.      # # 2 2 ; ; )!(c!2!D  !*!#s+!(c!2!D  ??0 0%F9eyDO DOO,G,GiXDK__++F #J/J ??o -(..tzz&.IDO(..f.=DO%)__%I%I" -diiZ=S=S8T.U-VVWX  s  G55?H4r/c.|jjSNrsrr;s r'rWz*SpeakerDiarization.segmentation_batch_sizes!!,,,r)rc&||j_yrr)r;rs r'rWz*SpeakerDiarization.segmentation_batch_sizes(2%r)cddidddddS)Nrcr\g333333?gQ?g?)rdFaFb)rJrUrGrs r'default_parametersz%SpeakerDiarization.default_parameters!s/5(+4sC  r)c#,Kd} d|d|dz }w)NrSPEAKER_02drQrG)r;r5s r'classeszSpeakerDiarization.classes's+WSM* * qLGscy)Nztraining_cache/segmentationrGrs r'CACHED_SEGMENTATIONz&SpeakerDiarization.CACHED_SEGMENTATION-s,r)c|tj|dd}|jrC|j|vr||j}|S|j ||}|||j<|S|j ||}|S)zApply segmentation model Parameter --------- file : AudioFile hook : Optional[Callable] Returns ------- segmentations : (num_chunks, num_frames, num_speakers) SlidingWindowFeature NrJhook) functoolspartialtrainingrrs)r;filer segmentationss r'get_segmentationsz$SpeakerDiarization.get_segmentations1s  $$T>4@D ==''4/ $T%=%= >  !% 2 24d 2 C 1>T--.372D2DTPT2D2UMr)binary_segmentationsexclude_overlaprcjrijdt}d|vrKjjj j s|djjk(r|dSjj}jj\}}} |rjj} |jjz} t!j"|| z| z dt%j&jdddkz} t)j| zjn"dt)jjfd } t+| j,d }t!j"|| zj,z }g}| |dd |d t/|dD]x\}}t1t3d|\}}t5j6|}t5j6|}j||}|j9||m|d|||zt%j6|}t;|d|}jrOjjj j r d|id<|Sjj|dd<|S)aExtract embeddings for each (chunk, speaker) pair Parameters ---------- file : AudioFile binary_segmentations : (num_chunks, num_frames, num_speakers) SlidingWindowFeature Binarized segmentation. exclude_overlap : bool, optional Exclude overlapping speech regions when extracting embeddings. In case non-overlapping speech is too short, use the whole speech. hook: Optional[Callable] Called during embeddings after every batch to report the progress Returns ------- embeddings : (num_chunks, num_speakers, dimension) array ztraining_cache/embeddings embeddingssegmentation.thresholdrbT)axiskeepdimsc3Kt D]\\}}\}} jj |d\}}tj|dj tj }tj|dj tj }t|j|jD]A\}}tj| kDr|}n|}|dtj|dfCyw)Npad)moder\)nan) ziprwcroprC nan_to_numastypefloat32Tsumtorch from_numpy) chunkmasksr= clean_maskswaveformmask clean_mask used_maskrclean_segmentationsrmin_num_framesr;s r'iter_waveform_and_maskzASpeakerDiarization.get_embeddings..iter_waveform_and_masks47$&95 L0 0K #kk../ ! e5<z3SpeakerDiarization.get_embeddings..sQqT5Er))rz(c s) d -> c s d)c)rr)rgetrErsrtrrrurJrdsliding_windowr_datashapervmin_num_samplesrhmathceilrCrrr(rV enumeraterfilterrvstackr9r )r;rrrrcacher_ num_chunks num_frames num_speakersr num_samples clean_framesrbatches batch_countembedding_batchesibatch waveformsrwaveform_batch mask_batchembedding_batchrrrs``` @@r'get_embeddingsz!SpeakerDiarization.get_embeddingsLs: ==HH8$&AE%""((77@@23t7H7H7R7RR\**'66??/C/H/H/N/N, J #oo==O#T__%@%@@K!YYzO'Ck'QRN+00q4H1LL#7$))L8$33#   N"6$))+?+N+N#  L L< " $00"  ii \ 9Dtjddjt |j |j ||}t|||\}}}|jrL|Jt|tr!d|vrt|dj}ntd|jd|j||}|d ||jj \}} } |j"j$j&j(r|} n"t+||j,j.d } |j1| |j"j$j2d } |d| t5j6| jdk(rkt9t;|dt;|dt5j<d|j>j@f} |jBr | jDS| S|jG|| |jH|}|d||jK|| |||||j"j$j2\}}}t5jL|dz}||ks||kDr;tjtOjPd|d|dd|d|d|d t5jR| j|jUt4jV| _t5jX| jddk(}d||<|j[||| }|d||j]|d|j,j^}|d|_0t5jR| jdjUt4jV| _|j[||| }|j]|d|j,j^}|d|_0d|vrN|drI|jc|d|d !\}}|jDcic]}||je||}}n;tg|j|jiDcic]\}}|| }}}|jk|"}|jk|"}|(t9|||} |jBr | jDS| St|j|j dkDrAt5jl|dt|j|j dz fd#f}|joDcic]\}}|| }}}||jDcgc]}|| c}}t9|||} |jBr | jDS| Scc}wcc}}wcc}}wcc}w)$aCApply speaker diarization Parameters ---------- file : AudioFile Processed file. num_speakers : int, optional Number of speakers, when known. min_speakers : int, optional Minimum number of speakers. Has no effect when `num_speakers` is provided. max_speakers : int, optional Maximum number of speakers. Has no effect when `num_speakers` is provided. hook : callable, optional Callback called after each major steps of the pipeline as follows: hook(step_name, # human-readable name of current step step_artefact, # artifact generated by current step file=file) # file being processed Time-consuming steps call `hook` multiple times with the same `step_name` and additional `completed` and `total` keyword arguments usable to track progress of current step. Returns ------- output : DiarizeOutput (or Annotation if `self.legacy` is True) rz'Ignoring unexpected keyword arguments: rjr)rrr annotationz)num_speakers must be provided when using z clusteringrJF)onset initial_state)r\r\)warm_upspeaker_countingr\uri)r)r,r-r.)rrr)rrr min_clusters max_clustersrframesrQz2 The detected number of speakers (z) for z. is outside the given bounds [zS]. This can happen if the given audio file is too short to contain zh or more speakers. Try to lower the desired minimal number of speakers. rrdiscrete_diarization)min_duration_onrcT)return_mapping)mapping)rr)8lenwarningswarnrzr{keys setup_hookrr isinstancerlabelsryrqrrrrsrtrrrurrJrd speaker_countreceptive_fieldrCnanmaxr+rrrv dimensionrRr,rrTrUrtextwrapdedentminimumrint8rr to_annotationrcroptimal_mappingrrr rename_labelsritems)r;rrrrrkwargsrrrrbinarized_segmentationsroutputrrr= centroidsnum_different_speakersinactive_speakersrr6exclusive_discrete_diarizationr7rkeylabelexpected_labelindexinverse_mappings r'applyzSpeakerDiarization.applysH v;? MM9$))DDW:X9YZ  t$/3C%%%4 0 lL  % %,*>$(\T-A"4 #5#<#<#>? !??PP[\..t$.?  ^]+5B5G5G5M5M2 J 2    # # 2 2 ; ;&3 # )-)9)9   * & !% 2 2 *!..??!3!  %)K! 4 D$6--\"K.JAw>I=O=O=QRcsGKKS11RGR.11C1C1Et||~-V)E>~%G "///@ 5 C CG C T  "$/.C#,F {{111M {!!# $yq'9 9QK$6$6$8 9IOOA!&#' R3R R x Rh0C+0Czz0C$ 0C  0Cj'+&*&*#' ~~sm~sm ~ sm ~ x ~  #~@>6>r)rI) N)7rrr#rrrpathlibrtypingrrrrrr dataclassesr numpyrCreinopsr pyannote.audior r rrpyannote.audio.core.ior#pyannote.audio.pipelines.clusteringr-pyannote.audio.pipelines.speaker_verificationrpyannote.audio.pipelines.utilsrrrrr*pyannote.audio.pipelines.utils.diarizationrpyannote.audio.utils.signalr pyannote.corerrpyannote.metrics.diarizationrpyannote.pipeline.parameterrrrr(r+rIrGr)r'r3s0$ @@! <<,:TH0:C:=3= < <  < ~T >0(T >r)