o GÿÆi ã@shddlmZddlmZddlZddlZddlZddlmZddlmZddlm Z Gdd „d e ƒZ dS) é)ÚList)ÚTupleN)ÚFsa)ÚDecodeStateInfoé)Ú DenseFsaVecc@sXeZdZdededededededdfd d „Zd ed ee de eee ffd d„Z dS)ÚOnlineDenseIntersecterÚdecoding_graphÚ num_streamsÚ search_beamÚ output_beamÚmin_active_statesÚmax_active_statesÚreturnNcCs,||_|j|_t |jj|||||¡|_dS)ay Create a new online intersecter object. Args: decoding_graph: The decoding graph used in this intersecter. num_streams: How many streams can this intersecter handle parallelly. search_beam: Decoding beam, e.g. 20. Smaller is faster, larger is more exact (less pruning). This is the default value; it may be modified by ``min_active_states`` and ``max_active_states``. output_beam: Pruning beam for the output of intersection (vs. best path); equivalent to kaldi's lattice-beam. E.g. 8. min_active_states: Minimum number of FSA states that are allowed to be active on any given frame for any given intersection/composition task. This is advisory, in that it will try not to have fewer than this number active. Set it to zero if there is no constraint. max_active_states: Maximum number of FSA states that are allowed to be active on any given frame for any given intersection/composition task. This is advisory, in that it will try not to exceed that but may not always succeed. You can use a very large number if no constraint is needed. Examples: .. code-block:: python # create a ``OnlineDenseIntersecter`` which can handle 2 streams. intersecter = k2.OnlineDenseIntersecter(...,num_streams=2,...) # decode_states stores the info of decoding states for each # sequences, suppose there are 3 sequences. decode_states = [None] * 3 # now, we want to decode first chunk of sequence 1 and sequence 2 # gather their history decoding states from ``decode_states`` current_decode_states = [decode_states[1], decode_states[2]] lattice, new_decode_states = intersecter.decode( dense_fsas_12, current_decode_states ) # we can get the partial results from ``lattice`` here. # update the decoding states of sequence 1 and sequence 2 decode_states[1] = new_decode_states[0] decode_states[2] = new_decode_states[1] # then, we want to decode first chunk of sequence 0 and second chunk # of sequence 1. # gather their history decoding states from ``decode_states`` current_decode_states = [decode_states[0], decode_states[1]] lattice, new_decode_states = intersecter.decode( dense_fsas_01, current_decode_states ) # we can get the partial results from ``lattice`` here. # update the decoding states of sequence 1 and sequence 2 decode_states[0] = new_decode_states[0] decode_states[1] = new_decode_states[1] ... N)r ÚdeviceÚ_k2rÚarcsÚ intersecter)Úselfr r r r r r©rúO/home/ubuntu/.local/lib/python3.10/site-packages/k2/online_dense_intersecter.pyÚ__init__s@ úzOnlineDenseIntersecter.__init__Ú dense_fsasÚ decode_statescCs0|j |j|¡\}}}tj |j||¡}||fS)aDoes intersection/composition for current chunk of nnet_output(given by a DenseFsaVec), sequences in every chunk may come from different sources. Args: dense_fsas: The neural-net output, with each frame containing the log-likes of each modeling unit. decode_states: A list of history decoding states for current batch of sequences, its length equals to ``dense_fsas.dim0()`` (i.e. batch size). Each element in ``decode_states`` belongs to the sequence at the corresponding position in current batch. For a new sequence(i.e. has no history states), just put ``None`` at the corresponding position. Return: Return a tuple containing an Fsa and a List of new decoding states. The Fsa which has 3 axes(i.e. (batch, state, arc)) contains the output lattices. See the example in the constructor to get more info about how to use the list of new decoding states. )rÚdecodeÚ dense_fsa_vecÚk2ÚutilsÚfsa_from_unary_function_tensorr )rrrÚ ragged_arcÚarc_mapÚnew_decode_statesÚout_fsarrrris ÿÿzOnlineDenseIntersecter.decode) Ú__name__Ú __module__Ú __qualname__rÚintÚfloatrrrrrrrrrrrs.þýüûúù øKÿÿþr) ÚtypingrrrÚtorchrrrrrÚobjectrrrrrÚs