o
    }oi                  	   @   s   d dl mZ d dlmZmZ d dlZd dlmZ d dlm	Z	m
Z
mZ d dlmZ d dlmZ eG dd	 d	ZG d
d dZdejdedejfddZddejdededejfddZdejdejdejfddZdS )    )	dataclass)ListOptionalN)
DictConfig)BeamSearchSequenceGeneratorGreedySequenceGeneratorTopKSequenceGenerator)TokenizerSpec)NeuralModulec                   @   sV   e Zd ZU dZeed< dZeed< dZeed< dZ	e
ed< d	Zeed
< dZe
ed< dS )SequenceGeneratorConfiggreedytype   max_sequence_lengthmax_delta_length      ?temperature   	beam_size        len_penN)__name__
__module____qualname__r   str__annotations__r   intr   r   floatr   r    r   r   ^/home/ubuntu/.local/lib/python3.10/site-packages/nemo/collections/asr/parts/utils/slu_utils.pyr       s   
 r   c                       s   e Zd ZdZdZdZdZeeegZdede	de	de	d	e
d
df fddZ				ddejdejdedee def
ddZdejd
ejfddZdejd
ee fddZ  ZS )SequenceGeneratorzF
    Wrapper class for sequence generators for NeMo transformers.
    r   topkbeamcfg	embeddingdecoderlog_softmax	tokenizerreturnNc           
   	      s<  t    |dd| _|| _t|dd| _t|dd| _t|dd| _| j| j| j|dd	|d
d|ddd}| j| j	krOt
|||fi || _d S | j| jkrp|dd}|dd}t|||||fi || _d S | j| jkr|dd}|dd}	t|||||	fi || _d S td| j d| j d)Nr   r   pad_idr   eos_idr   bos_idr   r   r   
batch_sizer   )padboseosr   r   r-   r   r   r   r   r   z(Sequence Generator only supports one of z
, but got z	 instead.)super__init__get_typer(   getattrr*   r+   r,   TYPE_GREEDYr   	generator	TYPE_TOPKr   	TYPE_BEAMr   
ValueErrorSEARCH_TYPES)
selfr$   r%   r&   r'   r(   common_argsr   r   r   	__class__r   r    r2   4   sD   





zSequenceGenerator.__init__Fencoder_statesencoder_input_maskreturn_beam_scorespad_max_lenreturn_lengthc                 C   s8   | j |||d}|rt||| j}|r|| |fS |S )a  
        Generate sequence tokens given the input encoder states and masks.
        Params:
        -   encoder_states: a torch Tensor of shape BxTxD
        -   encoder_input_mask: a binary tensor of shape BxTxD
        -   return_beam_scores: whether to return beam scores
        -   pad_max_len: optional int, set it to pad all sequence to the same length
        -   return_length: whether to return the lengths for generated sequences (shape B)
        Returns:
        -   generated tokens tensor of shape BxT
        )encoder_hidden_statesrA   rB   )r7   pad_sequencer*   get_seq_length)r<   r@   rA   rB   rC   rD   predictionsr   r   r    __call__^   s   zSequenceGenerator.__call__seqc                 C   sd   | dtj| d|jd  }|| jk  }tj|d|dddf |dddf d}|S )z
        Get sequence length.
        Params:
        -   seq: batched sequence tensor of shape BxTxD
        Returns:
        -   tensor of shape B, where each element is the length of the sequence
        r   r   deviceNdimindexsrc)sizetorchonesrL   longr+   nonzeroscatter)r<   rJ   lengthsposseq_lengthsr   r   r    rG      s   $*z SequenceGenerator.get_seq_length
seq_tokensc                 C   s   g }|    }| |}t|jd D ])}||   }||    }|d| }d	| j
j
|}|| q|S )z
        Decode tokens into strings
        Rarams:
        -   seq_tokens: integer tensor of shape BxT
        Returns:
        -   list of strings
        r   N )detachrT   cpurG   rangeshapenumpytolistitemjoinr(   
decode_idsappend)r<   rZ   semantics_listrY   indtokenslengthtextr   r   r    decode_semantics_from_tokens   s   
z.SequenceGenerator.decode_semantics_from_tokens)NFNF)r   r   r   __doc__r6   r8   r9   SEARCHER_TYPESr   r
   r	   r2   rR   Tensorboolr   r   rI   rG   r   r   rk   __classcell__r   r   r>   r    r!   *   sH    
-
! r!   rJ   r+   r)   c                 C   sb   |  dtj|  d| jd  }| |k  }tj|d|dddf |dddf d}|S )z
    Get sequence length.
    Params:
    -   seq: batched sequence tensor of shape BxTxD
    -   eos_id: integer representing the end of sentence
    Returns:
    -   tensor of shape B, where each element is the length of the sequence
    r   r   rK   NrM   )rQ   rR   rS   rL   rT   rU   rV   )rJ   r+   rW   rX   rY   r   r   r    rG      s   $	*rG   max_len	pad_tokenc                 C   sR   |  d}|  d}||kr| S tj||| | j| jd|}tj| |gddS )z
    Params:
        - seq: integer token sequences of shape BxT
        - max_len: integer for max sequence length
        - pad_token: integer token for padding
    Returns:
        - padded sequence of shape B x max_len
    r   r   )dtyperL   )rN   )rQ   rR   zerosrs   rL   fill_cat)rJ   rq   rr   batchcurr_lenpaddingr   r   r    rF      s   
	
 rF   seq_lensc                 C   sD   t | ddddf | j|dddf k }|j| jtdS )z
    Get the sequence mask based on the actual length of each sequence
    Params:
        - seq: tensor of shape [BxLxD]
        - seq_len: tensor of shape [B]
    Returns:
        - binary mask of shape [BxL]
    r   N)rs   )rR   arangerQ   torL   ro   )rJ   rz   maskr   r   r    get_seq_mask   s   4	r~   )r   )dataclassesr   typingr   r   rR   	omegaconfr   (nemo.collections.asr.modules.transformerr   r   r   1nemo.collections.common.tokenizers.tokenizer_specr	   nemo.core.classes.moduler
   r   r!   rn   r   rG   rF   r~   r   r   r   r    <module>   s   	x  