U %d;5@s`ddlZddlZddlmZmZddlmZddlmZddl m Z m Z m Z ddl Z ddlZddlmZddlmZmZmZgZdee e jjZed d eZd d ZGd dde jjZ Gddde jjZ!GdddeZ"GdddeZ#Gddde jje"Z$Gddde#Z%eGdddZ&e&deeddddd d!d"d#d$d%d&d d' Z'd(e'_(dS))N)ABCabstractmethod) dataclass)partial)CallableListTuple) module_utils)emformer_rnnt_baseRNNTRNNTBeamSearch( g?cCs@t||tjk||tjk<||tjktj||tjk<|SN)torchlogmathexrF/tmp/pip-unpacked-wheel-lbdmvq91/torchaudio/pipelines/rnnt_pipeline.py_piecewise_linear_logsrcs$eZdZfddZddZZS)_FunctionalModulecst||_dSr)super__init__ functional)selfr __class__rrrs z_FunctionalModule.__init__cCs ||Sr)rrinputrrrforwardsz_FunctionalModule.forward__name__ __module__ __qualname__rr" __classcell__rrrrrs rcs$eZdZfddZddZZS)_GlobalStatsNormalizationc s\tt|}t|}W5QRX|dt|d|dt|ddS)Nmean invstddev) rropenjsonloadsreadZregister_bufferrtensor)rZglobal_stats_pathfZblobrrrr$s   z"_GlobalStatsNormalization.__init__cCs||j|jSr)r)r*r rrrr"-sz!_GlobalStatsNormalization.forwardr#rrrrr(#s r(c@s.eZdZeejeejejfdddZdS)_FeatureExtractorr!returncCsdS)XGenerates features and length output from the given input tensor. Args: input (torch.Tensor): input tensor. Returns: (torch.Tensor, torch.Tensor): torch.Tensor: Features, with shape `(length, *)`. torch.Tensor: Length, with shape `(1,)`. Nrr rrr__call__2sz_FeatureExtractor.__call__N)r$r%r&rrTensorrr5rrrrr11sr1c@s$eZdZeeeedddZdS)_TokenProcessor)tokensr3cKsdS)zDecodes given list of tokens to text sequence. Args: tokens (List[int]): list of tokens to decode. Returns: str: Decoded text sequence. Nr)rr8kwargsrrrr5Csz_TokenProcessor.__call__N)r$r%r&rrintstrr5rrrrr7Bsr7csJeZdZdZejjddfdd Zeje ejejfdddZ Z S) _ModuleFeatureExtractorz``torch.nn.Module``-based feature extraction pipeline. Args: pipeline (torch.nn.Module): module that implements feature extraction logic. N)pipeliner3cst||_dSr)rrr=)rr=rrrrWs z _ModuleFeatureExtractor.__init__r2cCs$||}t|jdg}||fS)r4r)r=rr/shape)rr!featureslengthrrrr"[s z_ModuleFeatureExtractor.forward) r$r%r&__doc__rnnModulerr6rr"r'rrrrr<Psr<c@s8eZdZdZeddddZd eeeeddd Z dS) _SentencePieceTokenProcessorztSentencePiece-model-based token processor. Args: sp_model_path (str): path to SentencePiece model. N) sp_model_pathr3cCsJtdstdddl}|j|d|_|j|j|jh|_ dS)N sentencepiecez2SentencePiece is not available. Please install it.r)Z model_file) r Zis_module_available RuntimeErrorrFZSentencePieceProcessorsp_modelZunk_idZeos_idZpad_idpost_process_remove_list)rrEZspmrrrrts z%_SentencePieceTokenProcessor.__init__T)r8lstripr3csHfdd|ddD}dj|dd}|r@|S|SdS)aXDecodes given list of tokens to text sequence. Args: tokens (List[int]): list of tokens to decode. lstrip (bool, optional): if ``True``, returns text sequence with leading whitespace removed. (Default: ``True``). Returns: str: Decoded text sequence. csg|]}|jkr|qSr)rI).0Z token_indexrrr s z9_SentencePieceTokenProcessor.__call__..Nu▁ )joinrHZ id_to_piecereplacerJ)rr8rJZfiltered_hypo_tokensZ output_stringrrLrr5s  z%_SentencePieceTokenProcessor.__call__)T) r$r%r&rAr;rrr:boolr5rrrrrDms rDc@sLeZdZUdZGdddeZGdddeZee d<e ge fe d<ee d<ee d <e e d <e e d <e e d <e e d <e e d<e e d<e e d<e e d<e dddZ ee dddZee dddZee dddZee dddZee dddZee ddd Zedd!d"Zedd#d$Zedd%d&Zedd'd(Zd)S)* RNNTBundleutorchaudio.pipelines.RNNTBundle() Dataclass that bundles components for performing automatic speech recognition (ASR, speech-to-text) inference with an RNN-T model. More specifically, the class provides methods that produce the featurization pipeline, decoder wrapping the specified RNN-T model, and output token post-processor that together constitute a complete end-to-end ASR inference pipeline that produces a text sequence given a raw waveform. It can support non-streaming (full-context) inference as well as streaming inference. Users should not directly instantiate objects of this class; rather, users should use the instances (representing pre-trained models) that exist within the module, e.g. :py:obj:`EMFORMER_RNNT_BASE_LIBRISPEECH`. Example >>> import torchaudio >>> from torchaudio.pipelines import EMFORMER_RNNT_BASE_LIBRISPEECH >>> import torch >>> >>> # Non-streaming inference. >>> # Build feature extractor, decoder with RNN-T model, and token processor. >>> feature_extractor = EMFORMER_RNNT_BASE_LIBRISPEECH.get_feature_extractor() 100%|███████████████████████████████| 3.81k/3.81k [00:00<00:00, 4.22MB/s] >>> decoder = EMFORMER_RNNT_BASE_LIBRISPEECH.get_decoder() Downloading: "https://download.pytorch.org/torchaudio/models/emformer_rnnt_base_librispeech.pt" 100%|███████████████████████████████| 293M/293M [00:07<00:00, 42.1MB/s] >>> token_processor = EMFORMER_RNNT_BASE_LIBRISPEECH.get_token_processor() 100%|███████████████████████████████| 295k/295k [00:00<00:00, 25.4MB/s] >>> >>> # Instantiate LibriSpeech dataset; retrieve waveform for first sample. >>> dataset = torchaudio.datasets.LIBRISPEECH("/home/librispeech", url="test-clean") >>> waveform = next(iter(dataset))[0].squeeze() >>> >>> with torch.no_grad(): >>> # Produce mel-scale spectrogram features. >>> features, length = feature_extractor(waveform) >>> >>> # Generate top-10 hypotheses. >>> hypotheses = decoder(features, length, 10) >>> >>> # For top hypothesis, convert predicted tokens to text. >>> text = token_processor(hypotheses[0][0]) >>> print(text) he hoped there would be stew for dinner turnips and carrots and bruised potatoes and fat mutton pieces to [...] >>> >>> >>> # Streaming inference. >>> hop_length = EMFORMER_RNNT_BASE_LIBRISPEECH.hop_length >>> num_samples_segment = EMFORMER_RNNT_BASE_LIBRISPEECH.segment_length * hop_length >>> num_samples_segment_right_context = ( >>> num_samples_segment + EMFORMER_RNNT_BASE_LIBRISPEECH.right_context_length * hop_length >>> ) >>> >>> # Build streaming inference feature extractor. >>> streaming_feature_extractor = EMFORMER_RNNT_BASE_LIBRISPEECH.get_streaming_feature_extractor() >>> >>> # Process same waveform as before, this time sequentially across overlapping segments >>> # to simulate streaming inference. Note the usage of ``streaming_feature_extractor`` and ``decoder.infer``. >>> state, hypothesis = None, None >>> for idx in range(0, len(waveform), num_samples_segment): >>> segment = waveform[idx: idx + num_samples_segment_right_context] >>> segment = torch.nn.functional.pad(segment, (0, num_samples_segment_right_context - len(segment))) >>> with torch.no_grad(): >>> features, length = streaming_feature_extractor(segment) >>> hypotheses, state = decoder.infer(features, length, 10, state=state, hypothesis=hypothesis) >>> hypothesis = hypotheses[0] >>> transcript = token_processor(hypothesis[0]) >>> if transcript: >>> print(transcript, end=" ", flush=True) he hoped there would be stew for dinner turn ips and car rots and bru 'd oes and fat mut ton pieces to [...] c@s eZdZdS)zRNNTBundle.FeatureExtractorNr$r%r&rrrrFeatureExtractorsrVc@s eZdZdS)zRNNTBundle.TokenProcessorNrUrrrrTokenProcessorsrW _rnnt_path_rnnt_factory_func_global_stats_path_sp_model_path_right_padding_blank _sample_rate_n_fft_n_mels _hop_length_segment_length_right_context_length)r3cCs6|}tj|j}t|}||||Sr) rY torchaudioutilsdownload_assetrXrloadZload_state_dicteval)rmodelpathZ state_dictrrr _get_models   zRNNTBundle._get_modelcCs|jS)zSSample rate (in cycles per second) of input waveforms. :type: int )r^rLrrr sample_rateszRNNTBundle.sample_ratecCs|jS)z7Size of FFT window to use. :type: int )r_rLrrrn_fftszRNNTBundle.n_fftcCs|jS)z`Number of mel spectrogram features to extract from input waveforms. :type: int )r`rLrrrn_melsszRNNTBundle.n_melscCs|jS)zdNumber of samples between successive frames in input expected by model. :type: int )rarLrrr hop_lengthszRNNTBundle.hop_lengthcCs|jS)zTNumber of frames in segment in input expected by model. :type: int )rbrLrrrsegment_lengthszRNNTBundle.segment_lengthcCs|jS)zcNumber of frames in right contextual block in input expected by model. :type: int )rcrLrrrright_context_length'szRNNTBundle.right_context_lengthcCs|}t||jS)zOConstructs RNN-T decoder. Returns: RNNTBeamSearch )rkr r])rrirrr get_decoder/szRNNTBundle.get_decoderc s^tjj}ttjtjj j j j j dtddtddt|tfddS)zzConstructs feature extractor for non-streaming (full-context) ASR. Returns: FeatureExtractor rlrmrnrocSs |ddSNrNrZ transposerrrrDz2RNNTBundle.get_feature_extractor..cSs t|tSrr_gainrrrrrvErwcstjj|dddjfS)Nr)rrBrpadr\rrLrrrvGrwrdrerfrZr<rrBZ SequentialZ transformsZMelSpectrogramrlrmrnrorr(r local_pathrrLrget_feature_extractor8s  z RNNTBundle.get_feature_extractorc CsPtj|j}ttjtjj |j |j |j |j dtddtddt|S)zvConstructs feature extractor for streaming (simultaneous) ASR. Returns: FeatureExtractor rscSs |ddSrtrurrrrrvWrwz.cSs t|tSrrxrrrrrvXrwr{r|rrrget_streaming_feature_extractorKs  z*RNNTBundle.get_streaming_feature_extractorcCstj|j}t|S)zQConstructs token processor. Returns: TokenProcessor )rdrerfr[rDr|rrrget_token_processor]szRNNTBundle.get_token_processorN)r$r%r&rAr1rVr7rWr;__annotations__rr r:rkpropertyrlrmrnrorprqr rrr~rrrrrrrTs@ J rTz(models/emformer_rnnt_base_librispeech.pti)Z num_symbolsz2pipeline-assets/global_stats_rnnt_librispeech.jsonz.pipeline-assets/spm_bpe_4096_librispeech.modelii>iP) rXrYrZr[r\r]r^r_r`rarbrcaPre-trained Emformer-RNNT-based ASR pipeline capable of performing both streaming and non-streaming inference. The underlying model is constructed by :py:func:`torchaudio.models.emformer_rnnt_base` and utilizes weights trained on LibriSpeech using training script ``train.py`` `here `__ with default arguments. Please refer to :py:class:`RNNTBundle` for usage instructions. ))r,rabcrrZ dataclassesr functoolsrtypingrrrrrdZtorchaudio._internalr Ztorchaudio.modelsr r r __all__log10ZiinfoZint16maxZ_decibelpowryrrBrCrr(r1r7r<rDrTZEMFORMER_RNNT_BASE_LIBRISPEECHrArrrrsJ    +O