o Gi@sddlmZddlmZddlmZddlmZddlZddlZddlZddlm Z ddl m Z dd l m Z dd lmZ dnd eeeeeeejfd eeejefd e fddZdej fddZd eeeeeefdeeeeeefd e fddZdej fddZde d e fddZ  dode de dejd ed!ed ee ee ejejfff d"d#Z $ dpd%e d&e d'ed!ed ee ee ejejfff d(d)Z $ dqd%e d&e d'ed*eed d+f d,d-Zde d e fd.d/Zdrde d0ed ee ee ejfffd1d2Zde d3ed e fd4d5Zdrde d0ed ee ee ejfffd6d7Zde d e fd8d9Z de d e fd:d;Z!de d e fdd?Z# $dsde d@ed e fdAdBZ$ej%j&fde dCej%d e fdDdEZ'de d e fdFdGZ( drde d0ed ee ee ejfffdHdIZ)de d3edJed ejfdKdLZ*de dMe+d3ed e fdNdOZ,  dtde d0edPeeed ee ee ejfffdQdRZ-  dudSe dTe dUed0ed ee ee ejejfff dVdWZ.  XdvdYeeeeejfdZed eeejefd e fd[d\Z/  dtd]edZed eeejefd ej fd^d_Z0 dnd]ed eeejefd ej fd`daZ1 b XdwdYeejeeefdce+d eeejefd e fdddeZ2 drdfe dge dhejdied e f djdkZ3de d e fdldmZ4dS)x)List)Optional)Tuple)UnionN)fsa_properties)Fsa) index_select)TensorlabelsdevicereturncCs0t|tjr |dus Jt||}t|}|S)awConstruct an linear FSA from labels. Note: The scores of arcs in the returned FSA are all 0. Args: labels: It can be one of the following types: - A list of integers, e.g., `[1, 2, 3]` - A list of list-of-integers, e..g, `[ [1, 2], [1, 2, 3] ]` - An instance of :class:`k2.RaggedTensor`. Must have `num_axes == 2`. device: Optional. It can be either a string (e.g., 'cpu', 'cuda:0') or a torch.device. If it is ``None``, then the returned FSA is on CPU. It has to be None if ``labels`` is an instance of :class:`k2.RaggedTensor`. Returns: - If ``labels`` is a list of integers, return an FSA - If ``labels`` is a list of list-of-integers, return an FsaVec - If ``labels`` is an instance of :class:`k2.RaggedTensor`, return an FsaVec N) isinstancek2 RaggedTensor_k2 linear_fsar)r r ragged_arcfsar?/home/ubuntu/.local/lib/python3.10/site-packages/k2/fsa_algo.pyr%s   rfsascCst|jdkr!|j}tjjd|jdd}|||j}n|j}| d}t ||j }|d}tt|}t|jdkrJ|d}|S)aCreate a linear FSA with epsilon self-loops by first removing epsilon transitions from the input linear FSA. Args: fsas: An FSA or an FsaVec. It MUST be a linear FSA or a vector of linear FSAs. Returns: Return an FSA or FsaVec, where each FSA contains epsilon self-loops but contains no epsilon transitions for arcs that are not self-loops. rrdim0dim1)lenshaper r RaggedShaperegular_ragged_shapetocomposearcs remove_axisrrr contiguousremove_values_leqadd_epsilon_self_loopsr)rr shape0rr ansrrrlinear_fsa_with_self_loopsGs     r) aux_labelscCst|}t|dtr/t|dtsJdg}|D] }||dgqtj|tjd}n tj|dgtjd}t ||d}|S)aConstruct a linear FST from labels and its corresponding auxiliary labels. Note: The scores of arcs in the returned FST are all 0. Args: labels: A list of integers or a list of list of integers. aux_labels: A list of integers or a list of list of integers. Returns: An FST if the labels is a list of integers. A vector of FSTs (FsaVec) if the input is a list of list of integers. rz#aux_labels and labels do not match.dtyper*) rrrrlistextendtorchtensorint32r)r r*rbufauxaux_labels_tmprrrr linear_fstfs  r7fstscCszt|dsJ|jdk}tjt|jtjd|j}|dd|dd<tj|dtjdd}t j j || d}t ||j}|d}tj|jtjd|j}t ||}t j |j|}t|jd kr|j} tjjd|jdd } | | |j} n|j} | d} t | |j} | d} t | } || _|| _t | } t|jd kr| d} | S) aCreate a linear FST with epsilon self-loops by first removing epsilon transitions from the input linear FST. Note: The main difference to :func:`linear_fsa_with_self_loops` is that aux_labels and scores are also kept here. Args: fsas: An FST or an FstVec. It MUST be a linear FST or a vector of linear FSTs. Returns: Return an FST or FstVec, where each FST contains epsilon self-loops but contains no epsilon transitions for arcs that are not self-loops. r*rr,r+rN)dimr-)row_idscached_tot_sizerr)hasattrr r1onesrr3r r cumsumrraggedcreate_ragged_shape2numelrr*r$r%aranger" num_elements index_and_sumscoresrrrrr!r#rr&)r8non_epsilon_positions new_arc_flagdest_arc_row_idsdest_arc_shapedest_aux_labels arc_indexesarc_map dest_scoresr r'rr r(rrrlinear_fst_with_self_loopssN          rNrcCs,d}tj|j|d\}}tj|||}|S)afSort an FSA topologically. Note: It returns a new FSA. The input FSA is NOT changed. Args: fsa: The input FSA to be sorted. It can be either a single FSA or a vector of FSAs. Returns: It returns a single FSA if the input is a single FSA; it returns a vector of FSAs if the input is a vector of FSAs. T need_arc_map)rtop_sortr"rutilsfsa_from_unary_function_tensorrrPrrLout_fsarrrrQsrQFa_fsasb_fsas b_to_a_mapsorted_match_a ret_arc_mapsc CsNd}t|j|j|j|j|||\}}}tj|||||} |r%| ||fS| S)a Compute the intersection of two FsaVecs treating epsilons as real, normal symbols. This function supports both CPU and GPU. But it is very slow on CPU. That's why this function name ends with `_device`. It is intended for GPU. See :func:`k2.intersect` which is a more general interface (it will call the same underlying code, IntersectDevice(), if the inputs are on GPU and a_fsas is arc-sorted). Caution: Epsilons are treated as real, normal symbols. Hint: The two inputs do not need to be arc-sorted. Refer to :func:`k2.intersect` for how we assign the attributes of the output FsaVec. Args: a_fsas: An FsaVec (must have 3 axes, i.e., `len(a_fsas.shape) == 3`. b_fsas: An FsaVec (must have 3 axes) on the same device as `a_fsas`. b_to_a_map: A 1-D torch.Tensor with dtype torch.int32 on the same device as `a_fsas`. Map from FSA-id in `b_fsas` to the corresponding FSA-id in `a_fsas` that we want to compose it with. E.g. might be an identity map, or all-to-zero, or something the user chooses. Requires - `b_to_a_map.shape[0] == b_fsas.shape[0]` - `0 <= b_to_a_map[i] < a_fsas.shape[0]` sorted_match_a: If true, the arcs of a_fsas must be sorted by label (checked by calling code via properties), and we'll use a matching approach that requires this. ret_arc_maps: If False, return the resulting Fsa. If True, return a tuple containing three entries: - the resulting Fsa - a_arc_map, a 1-D torch.Tensor with dtype torch.int32. a_arc_map[i] is the arc index in a_fsas that corresponds to the i-th arc in the resulting Fsa. a_arc_map[i] is -1 if the i-th arc in the resulting Fsa has no corresponding arc in a_fsas. - b_arc_map, a 1-D torch.Tensor with dtype torch.int32. b_arc_map[i] is the arc index in b_fsas that corresponds to the i-th arc in the resulting Fsa. b_arc_map[i] is -1 if the i-th arc in the resulting Fsa has no corresponding arc in b_fsas. Returns: If ret_arc_maps is False, return intersected FsaVec; will satisfy `ans.shape == b_fsas.shape`. If ret_arc_maps is True, it returns additionally two arc maps: a_arc_map and b_arc_map. T)rintersect_devicer" propertiesrrRfsa_from_binary_function_tensor) rVrWrXrYrZrPr a_arc_map b_arc_mapout_fsasrrrr[sD   r[Ta_fsab_fsatreat_epsilons_speciallyc Cs|s|r|jtj@dksJ|jtj@dksJd}t|j|j|j|j||\}}}tj |||||}|r@|||fS|S)a Compute the intersection of two FSAs. When `treat_epsilons_specially` is True, this function works only on CPU. When `treat_epsilons_specially` is False and both `a_fsa` and `b_fsa` are on GPU, then this function works on GPU; in this case, the two input FSAs do not need to be arc sorted. Args: a_fsa: The first input FSA. It can be either a single FSA or an FsaVec. b_fsa: The second input FSA. it can be either a single FSA or an FsaVec. If both a_fsa and b_fsa are FsaVec, they must contain the same number of FSAs. treat_epsilons_specially: If True, epsilons will be treated as epsilon, meaning epsilon arcs can match with an implicit epsilon self-loop. If False, epsilons will be treated as real, normal symbols (to have them treated as epsilons in this case you may have to add epsilon self-loops to whichever of the inputs is naturally epsilon-free). ret_arc_maps: If False, return the resulting Fsa. If True, return a tuple containing three entries: - the resulting Fsa - a_arc_map, a 1-D torch.Tensor with dtype torch.int32. a_arc_map[i] is the arc index in a_fsa that corresponds to the i-th arc in the resulting Fsa. a_arc_map[i] is -1 if the i-th arc in the resulting Fsa has no corresponding arc in a_fsa. - b_arc_map, a 1-D torch.Tensor with dtype torch.int32. b_arc_map[i] is the arc index in b_fsa that corresponds to the i-th arc in the resulting Fsa. b_arc_map[i] is -1 if the i-th arc in the resulting Fsa has no corresponding arc in b_fsa. Caution: The two input FSAs MUST be arc sorted if `treat_epsilons_specially` is True. Caution: The rules for assigning the attributes of the output Fsa are as follows: - (1) For attributes where only one source (a_fsa or b_fsa) has that attribute: Copy via arc_map, or use zero if arc_map has -1. This rule works for both floating point and integer attributes. - (2) For attributes where both sources (a_fsa and b_fsa) have that attribute: For floating point attributes: sum via arc_maps, or use zero if arc_map has -1. For integer attributes, it's not supported for now (the attributes will be discarded and will not be kept in the output FSA). Returns: If ret_arc_maps is False, return the result of intersecting a_fsa and b_fsa. len(out_fsa.shape) is 2 if and only if the two input FSAs are single FSAs; otherwise, len(out_fsa.shape) is 3. If ret_arc_maps is True, it returns additionally two arc_maps: a_arc_map and b_arc_map. rT) is_cpur\r ARC_SORTEDr intersectr"rrRr]) rarbrcrZrPrr^r_rUrrrrfKsC  rf inner_labelsrc Csz t|jts JWnty}ztdt|d}~ww|}t|}|dus.|r8|j t j @dks8J| ddt |||d}|durO| d|t|dsa|durYnJ| dd| dd|S) aCompute the composition of two FSAs. When `treat_epsilons_specially` is True, this function works only on CPU. When `treat_epsilons_specially` is False and both `a_fsa` and `b_fsa` are on GPU, then this function works on GPU; in this case, the two input FSAs do not need to be arc sorted. Note: `a_fsa.aux_labels` is required to be defined and it can be either a `torch.Tensor` or a ragged tensor of type `k2.RaggedTensor`. If it is a ragged tensor, then it requires that a_fsa.requires_grad is False. For both FSAs, the `aux_labels` attribute is interpreted as output labels, (olabels), and the composition involves matching the olabels of a_fsa with the ilabels of b_fsa. This is implemented by intersecting the inverse of a_fsa (a_fsa_inv) with b_fsa, then replacing the ilabels of the result with the original ilabels on a_fsa which are now the aux_labels of a_fsa_inv. If `b_fsa.aux_labels` is not defined, `b_fsa` is treated as an acceptor (as in OpenFST), i.e. its olabels and ilabels are assumed to be the same. Refer to :func:`k2.intersect` for how we assign the attributes of the output FSA. Args: a_fsa: The first input FSA. It can be either a single FSA or an FsaVec. b_fsa: The second input FSA. it can be either a single FSA or an FsaVec. treat_epsilons_specially: If True, epsilons will be treated as epsilon, meaning epsilon arcs can match with an implicit epsilon self-loop. If False, epsilons will be treated as real, normal symbols (to have them treated as epsilons in this case you may have to add epsilon self-loops to whichever of the inputs is naturally epsilon-free). inner_labels: If specified (and if a_fsa has `aux_labels`), the labels that we matched on, which would normally be discarded, will instead be copied to this attribute name. Caution: `b_fsa` has to be arc sorted if the function runs on CPU. Returns: The result of composing a_fsa and b_fsa. `len(out_fsa.shape)` is 2 if and only if the two input FSAs are single FSAs; otherwise, `len(out_fsa.shape)` is 3. z0Expected a_fsa to have aux_labels (not ragged): NTrr* left_labels)rcr )rr*r Exception ValueErrorstrinvertarc_sortrdr\rrerename_tensor_attribute_rfr<)rarbrcrge a_fsa_invr(rrrr!s05     r!cCsP|jtj@dkr|jtj@dkr|Sd}tj|j|d\}}tj |||}|S)aConnect an FSA. Removes states that are neither accessible nor co-accessible. Note: A state is not accessible if it is not reachable from the start state. A state is not co-accessible if it cannot reach the final state. Caution: If the input FSA is already connected, it is returned directly. Otherwise, a new connected FSA is returned. Args: fsa: The input FSA to be connected. Returns: An FSA that is connected. rTrO) r\r ACCESSIBLE COACCESSIBLErconnectr"rrRrSrTrrrrssrs ret_arc_mapcCsn|jtj@dkr|rtj|jtj|jd}||fS|Sd}tj |j |d\}}t j |||}|r5||fS|S)aSort arcs of every state. Note: Arcs are sorted by labels first, and then by dest states. Caution: If the input `fsa` is already arc sorted, we return it directly. Otherwise, a new sorted fsa is returned. Args: fsa: The input FSA. ret_arc_map: True to return an extra arc_map (a 1-D tensor with dtype being torch.int32). arc_map[i] is the arc index in the input `fsa` that corresponds to the i-th arc in the output Fsa. Returns: If ret_arc_map is False, return the sorted FSA. It is the same as the input `fsa` if the input `fsa` is arc sorted. Otherwise, a new sorted fsa is returned and the input `fsa` is NOT modified. If ret_arc_map is True, an extra arc map is also returned. **Example: Sort a single FSA** .. literalinclude:: ./code/arc_sort/main.py :language: python :linenos: :caption: Sort a single FSA .. figure:: code/arc_sort/arc_sort_single_before.svg :alt: Fsa before k2.arc_sort :align: center :figwidth: 600px .. figure:: code/arc_sort/arc_sort_single_after.svg :alt: Fsa before k2.arc_sort :align: center :figwidth: 600px .. figure:: code/arc_sort/arc_sort_single_after_aux_labels.svg :alt: Fsa before k2.arc_sort :align: center :figwidth: 600px rr-r TrO)r\rrer1rBnum_arcsr3r rrmr"rrRrS)rrtrLrPrrUrrrrms.rmuse_double_scorescCs6||}t|j|\}}|j}tj|||}|S)aReturn the shortest paths as linear FSAs from the start state to the final state in the tropical semiring. Note: It uses the opposite sign. That is, It uses `max` instead of `min`. Args: fsa: The input FSA. It can be either a single FSA or an FsaVec. use_double_scores: False to use float, i.e., single precision floating point, for scores. True to use double. Returns: FsaVec, it contains the best paths as linear FSAs )_get_entering_arcsr shortest_pathr"valuesrrRrS)rrw entering_arcsr ragged_intrLrUrrrryVs rycCs8d}tj|j|d\}}tj|||}|r||fS|S)a!Add epsilon self-loops to an Fsa or FsaVec. This is required when composing using a composition method that does not treat epsilons specially, if the other FSA has epsilons in it. Args: fsa: The input FSA. It can be either a single FSA or an FsaVec. ret_arc_map: If False, return the resulting Fsa. If True, return an extra arc map. Returns: If ret_arc_map is False, return an instance of :class:`Fsa` that has an epsilon self-loop on every non-final state. If ret_arc_map is True, it returns an extra arc_map. arc_map[i] is the arc index in the input `fsa` that corresponds to the i-th arc in the resulting Fsa. arc_map[i] is -1 if the i-th arc in the resulting Fsa has no counterpart in the input `fsa`. TrO)rr&r"rrRrS)rrtrPrrLrUrrrr&os r&cC*d}t|j|\}}tj|||}|S)afRemove epsilon self-loops of an Fsa or an FsaVec. Caution: Unlike :func:`remove_epsilon`, this funciton removes only epsilon self-loops. Args: fsa: The input FSA. It can be either a single FSA or an FsaVec. Returns: An instance of :class:`Fsa` that has no epsilon self-loops on every non-final state. T)rremove_epsilon_self_loopsr"rrRrSrTrrrr~sr~cCr})aReverse the input Fsa. If the input Fsa accepts string 'x' with weight 'x.weight', then the reversed Fsa accepts the reverse of string 'x' with weight 'x.weight.reverse'. As the Fsas of k2 run on the Log-semiring or Tropical-semiring, the 'weight.reverse' will equal to the orignal 'weight'. Args: fsa: The input FSA. It can be either a single FSA or an FsaVec. Returns: An instance of :class:`Fsa` which has been reversed. T)rreverser"rrRrSrTrrrrs rcCsRt|j|j\}}tjj|||dd}t|dr't|j tj r'|j d|_ |S)aRemove epsilons (symbol zero) in the input Fsa. Caution: Call :func:`k2.connect` if you are using a GPU version. Args: fsa: The input FSA. It can be either a single FSA or an FsaVec. Works either for CPU or GPU, but the algorithm is different. We can only use the CPU algorithm if the input is top-sorted, and the GPU algorithm, while it works for CPU, may not be very fast. `fsa` must be free of epsilon loops that have score greater than 0. Returns: The resulting Fsa is equivalent to the input `fsa` under the tropical semiring but will be epsilon-free. Any linear tensor attributes, such as 'aux_labels', will have been turned into ragged labels after removing fillers (i.e. labels whose value equals fsa.XXX_filler if the attribute name is XXX), counting -1's on final-arcs as fillers even if the filler value for that attribute is not -1. T remove_fillerr*r) rremove_epsilonr"r\rrRfsa_from_unary_function_raggedr<rr*rremove_values_eq)rrrLrUrrrrs  rcCst|S)zRA wrapper for remove_epsilon(), deprecated but provided for back compatibility)r)rrrr!remove_epsilon_iterative_tropicalsrrcCsD|jtj@dkr t|St|j|j\}}tjj ||||d}|S)aRemove epsilons (symbol zero) in the input Fsa, and then add epsilon self-loops to all states in the input Fsa (usually as a preparation for intersection with treat_epsilons_specially=0). Caution: Call :func:`k2.connect` if you are using a GPU version. Args: fsa: The input FSA. It can be either a single FSA or an FsaVec. remove_filler: If true, we will remove any `filler values` of attributes when converting linear to ragged attributes. Returns: The resulting Fsa. See :func:`remove_epsilon` for details. The only epsilons will be epsilon self-loops on all states. rr) r\r EPSILON_FREEr&r!remove_epsilon_and_add_self_loopsr"rrRr)rrrrLrUrrrrsrweight_pushing_typecCsT|sJ|jdus J|jtj@dkr|St|j|\}}tj |||}|S)aDeterminize the input Fsa. Caution: - It only works on for CPU. - Any weight_pushing_type value other than kNoWeightPushing causes the 'arc_derivs' to not accurately reflect the real derivatives, although this will not matter as long as the derivatives ultimately derive from FSA operations such as getting total scores or arc posteriors, which are insensitive to pushing. Args: fsa: The input FSA. It can be either a single FSA or an FsaVec. Must be connected. It's also expected to be epsilon-free, but this is not checked; in any case, epsilon will be treated as a normal symbol. weight_pushing_type: An enum value that determines what kind of weight pushing is desired, default kNoWeightPushing. kTropicalWeightPushing: use tropical semiring (actually, max on scores) for weight pushing. kLogWeightPushing: use log semiring (actually, log-sum on score) for weight pushing kNoWeightPushing: do no weight pushing; this will cause some delay in scores being emitted, and the weights created in this way will correspond exactly to those that would be produced by the arc_derivs. For decoding graph creation, we recommend kLogSumWeightPushing. Returns: The resulting Fsa, it's equivalent to the input `fsa` under tropical semiring but will be deterministic. It will be the same as the input `fsa` if the input `fsa` has property kFsaPropertiesArcSortedAndDeterministic. Otherwise, a new deterministic fsa is returned and the input `fsa` is NOT modified. Fr) rd requires_gradr\rARC_SORTED_AND_DETERMINISTICr determinizer"rrRr)rrrrLrUrrrr s )rc Csdtjdtjdtjdtjfdd}d}tj|j|d\}}t|}|D]\}}|d kr8|||jd |}nt||}t |||q%| D] \}}t |||qH|S) zCompute the Kleene closure of the input FSA. Args: fsa: The input FSA. It has to be a single FSA. That is, len(fsa.shape) == 2. Returns: The resulting FSA which is the Kleene closure of the input FSA. src_aux_labelssrc_row_splits1rLr cSsLtj|dkdd}|d}|||kd7<t||}d||<d||<|S)aFix the aux labels of the output FSA. Since :func:`_k2.closure` changes the labels of arcs entering the final state to 0, we need to change their corresponding aux labels to 0. Args: src_aux_labels: The aux labels of the input FSA. src_row_splits: The row splits1 of the input FSA. arc_map: The arc map produced by :func:`_k2.closure`. Returns: The aux_labels of the output fsa after converting -1 to 0. r+F)as_tuplerr)r1nonzeror )rrrLminus_one_indexsrc_start_state_last_arc_indexans_aux_labelsrrrfix_aux_labelsGs zclosure..fix_aux_labelsTrOr*r) r1r rclosurer"rnamed_tensor_attr row_splitsr setattrnamed_non_tensor_attr) rrrPrrLrUnamevalue new_valuerrrr<s$   rcCst|jtjr |dur|Stj|jtj|jd}||fSt|jt j s)J|jj tjks2Jt |ddgd\}}| }|rF||fS|S)aInvert an FST, swapping the labels in the FSA with the auxiliary labels. Args: fsa: The input FSA. It can be either a single FSA or an FsaVec. ret_arc_map: True to return an extra arc map, which is a 1-D tensor with dtype torch.int32. The returned arc_map[i] is the arc index in the input fsa that corresponds to the i-th arc in the returned fsa. arc_map[i] is -1 if the i-th arc in the returned fsa has no counterpart in the input fsa. Returns: If ret_arc_map is False, return the inverted Fsa, it's top-sorted if `fsa` is top-sorted. If ret_arc_map is True, return an extra arc map. FruTr*)rtragged_attribute_names)rr*r1r rlrBrvr3r rrr-expand_ragged_attributesinvert_)rrtrLrrrrlvs"  rl num_pathsc Csh|dks Jd|d}|j||d}|j||d}|}|r%tj}ntj}||j||||d}|S)axCompute pseudo-random paths through the FSAs in this vector of FSAs (this object must have 3 axes, `self.arcs.num_axes() == 3`) Caution: It does not support autograd. Caution: Do not be confused by the function name. There is no randomness at all, thus no `seed`. It uses a deterministic algorithm internally, similar to arithmetic coding (see ``_). Look into the C++ implementation code for more details. Args: fsas: A FsaVec, i.e., `len(fsas.shape) == 3` use_double_scores: If true, do computation with double-precision, else float (single-precision) num_paths: Number of paths requested through each FSA. FSAs that have no successful paths will have zero paths returned. Returns: Returns a k2.RaggedTensor (dtype is torch.int32) with 3 axes: [fsa][path][arc_pos]; the final sub-lists (indexed with arc_pos) are sequences of arcs starting from the start state and terminating in the final state. The values are arc_idx012, i.e. arc indexes. rz num_paths: Trw log_semiring)rarc_cdfr tot_scores state_batches) _get_arc_cdf_get_tot_scores_get_state_batchesrrandom_paths_doublerandom_paths_floatr") rrwrrrrrfuncr(rrr random_pathss& rthreshold_probc CsL|j|dd}d}|rtj}ntj}||j|||\}}tj|||}|S)aRemove arcs whose posteriors are less than the given threshold. Args: fsas: An FsaVec. Must have 3 axes. threshold_prob: Arcs whose posteriors are less than this value are removed. Note: 0 < threshold_prob < 1 use_double_scores: True to use double precision during computation; False to use single precision. Returns: Return a pruned FsaVec. Tr) get_arc_postrprune_on_arc_post_doubleprune_on_arc_post_floatr"rrRrS) rrrwarc_postrPrrrLrUrrrprune_on_arc_posts  rrcs|dur,g}g}jddD]\}}t|tjr*|||||jtjks*Jqnfdd|D}|D]}t|tjsAJ|jtjksIJq7t|dkrc|ratj j tjj d}|fSSt j|\}} }t|} jddD]C\}}t|tjrt|} t||| d} t| || qw||vrt|tjsJ|jtjksJ|j|ddd \} } t| || qwt|| D] \}}t| ||qD] \}}t| ||qtj| j|t| d rt | j| j|r| |fS| S) a Turn ragged labels attached to this FSA into linear (Tensor) labels, expanding arcs into sequences of arcs as necessary to achieve this. Supports autograd. If `fsas` had no ragged attributes, returns `fsas` itself. Caution: This function will ensure that for final-arcs in the returned fsa, the corresponding labels for all ragged attributes are -1; it will add an extra arc at the end if necessary to ensure this, if the original ragged attributes did not have -1 as their final element on final-arcs (note: our intention is that -1's on final arcs, like filler symbols, are removed when making attributes ragged; this is what fsa_from_unary_function_ragged() does if remove_filler==True (the default). Args: fsas: The source Fsa ret_arc_map: If true, will return a pair (new_fsas, arc_map) with `arc_map` a tensor of int32 that maps from arcs in the result to arcs in `fsas`, with -1's for newly created arcs. If false, just returns new_fsas. ragged_attribute_names: If specified, just this list of ragged attributes will be expanded to linear tensor attributes, and the rest will stay ragged. NF)include_scorescsg|]}t|qSr)getattr).0rrrr s z,expand_ragged_attributes..rru) default_value)axisneed_value_indexesr*)rrrrappendr-r1r3rrBrvr r expand_arcsr"rr float get_fillerr rindexziprautograd_utilsphantom_index_select_scoresrEr<fix_final_labelsr*)rrtrragged_attribute_tensorsrrtrL dest_arcs dest_labelsdestfillerr_rrrrsh!         rsrcrsymbol_begin_rangecCs>t|j|j|\}}}tj|||||}|r|||fS|S)a Replace arcs in index FSA with the corresponding fsas in a vector of FSAs(src). For arcs in `index` with label `symbol_range_begin <= label < symbol_range_begin + src.Dim0()` will be replaced with fsa indexed `label - symbol_begin_range` in `src`. The destination state of the arc in `index` is identified with the `final-state` of the corresponding FSA in `src`, and the arc in `index` will become an epsilon arc leading to a new state in the output that is a copy of the start-state of the corresponding FSA in `src`. Arcs with labels outside this range are just copied. Labels on final-arcs in `src` (Which will be -1) would be set to 0(epsilon) in the result fsa. Caution: Attributes of the result inherits from `index` and `src` via `arc_map_index` and `arc_map_src`, But if there are attributes with same name, only the attributes with dtype `torch.float32` are supported, the other kinds of attributes are discarded. See docs in `fsa_from_binary_function_tensor` for details. Args: src: Fsa that we'll be inserting into the result, MUST have 3 axes. index: The Fsa that is to be replaced, It can be a single FSA or a vector of FSAs. symbol_range_begin: Beginning of the range of symbols that are to be replaced with Fsas. ret_arc_map: if true, will return a tuple (new_fsas, arc_map_index, arc_map_src) with `arc_map_index` and `arc_map_src` tensors of int32 that maps from arcs in the result to arcs in `index` and `src` , with -1's for the arcs not mapped. If false, just returns new_fsas. )r replace_fsar"rrRr])rrrrtdest_arc arc_map_src arc_map_indexrrrrrVs(  rcpusymbolsmodifiedcCs:t|tjs tj||d}t||\}}t||d}|S)av Construct ctc graphs from symbols. Note: The scores of arcs in the returned FSA are all 0. Args: symbols: It can be one of the following types: - A list of list-of-integers, e..g, `[ [1, 2], [1, 2, 3] ]` - An instance of :class:`k2.RaggedTensor`. Must have `num_axes == 2`. standard: Option to specify the type of CTC topology: "standard" or "simplified", where the "standard" one makes the blank mandatory between a pair of identical symbols. Default True. device: Optional. It can be either a string (e.g., 'cpu', 'cuda:0') or a torch.device. By default, the returned FSA is on CPU. If `symbols` is an instance of :class:`k2.RaggedTensor`, the returned FSA will on the same device as `k2.RaggedTensor`. Returns: An FsaVec containing the returned ctc graphs, with "Dim0()" the same as "len(symbols)"(List[List[int]]) or "dim0"(k2.RaggedTensor) **Example 1** .. literalinclude:: ./code/ctc_graph/main.py :language: python :linenos: :caption: Usage of k2.ctc_graph .. figure:: code/ctc_graph/ctc_graph.svg :alt: CTC graph (modified=False) :align: center :figwidth: 600px Note: There is a mandatory blank between state 3 and 5. .. figure:: code/ctc_graph/modified_ctc_graph.svg :alt: CTC graph (modified=True) :align: center :figwidth: 600px Note: There is **no** mandatory blank between state 3 and 5. **Example 2 Construct a CTC graph using composition** .. literalinclude:: ./code/ctc_graph/main2.py :language: python :linenos: :caption: Construct a CTC graph using composition .. figure:: code/ctc_graph/linear_fsa.svg :alt: Linear FSA :align: center :figwidth: 600px .. figure:: code/ctc_graph/ctc_topo.svg :alt: CTC topology (modified=False) :align: center :figwidth: 600px .. figure:: code/ctc_graph/ctc_topo_compose_linear_fsa.svg :alt: k2.compose(ctc_topo, linear_fsa) :align: center :figwidth: 600px .. figure:: code/ctc_graph/ctc_topo_modified.svg :alt: CTC topology (modified=True) :align: center :figwidth: 600px .. figure:: code/ctc_graph/ctc_topo_modified_compose_linear_fsa.svg :alt: k2.compose(ctc_topo_modified, linear_fsa) :align: center :figwidth: 600px r r.)rrrr ctc_graphr)rrr rr*rrrrrs T r max_tokencCs"t|||\}}t||d}|S)aCreate a CTC topology. A token which appears once on the right side (i.e. olabels) may appear multiple times on the left side (ilabels), possibly with epsilons in between. When 0 appears on the left side, it represents the blank symbol; when it appears on the right side, it indicates an epsilon. That is, 0 has two meanings here. A standard CTC topology is the conventional one, where there is a mandatory blank between two repeated neighboring symbols. A non-standard, i.e., modified CTC topology, imposes no such constraint. See https://github.com/k2-fsa/k2/issues/746#issuecomment-856421616 and https://github.com/k2-fsa/snowfall/pull/209 for more details. Args: max_token: The maximum token ID (inclusive). We assume that token IDs are contiguous (from 1 to `max_token`). 0 represents blank. modified: If False, create a standard CTC topology. Otherwise, create a modified CTC topology. device: Optional. It can be either a string (e.g., 'cpu', 'cuda:0') or a torch.device. If it is None, then the returned FSA is on CPU. Returns: Return either a standard or a modified CTC topology as an FSA depending on whether `standard` is True or False. **Example** .. literalinclude:: ./code/ctc_topo/main.py :language: python :linenos: :caption: Usage of k2.ctc_topo .. figure:: code/ctc_topo/ctc_topo.svg :alt: CTC topology :align: center :figwidth: 600px .. figure:: code/ctc_topo/modified_ctc_topo.svg :alt: CTC topology :align: center :figwidth: 600px r.)rctc_topor)rrr rr*rrrrrs4 rcCs t||\}}t||d}|S)aCreate a trivial graph which has only two states. On state 0, there are `max_token` self loops(i.e. a loop for each symbol from 1 to max_token), and state 1 is the final state. Args: max_token: The maximum token ID (inclusive). We assume that token IDs are contiguous (from 1 to `max_token`). device: Optional. It can be either a string (e.g., 'cpu', 'cuda:0') or a torch.device. If it is None, then the returned FSA is on CPU. Returns: Returns the expected trivial graph on the given device. Note: The returned graph does not contain arcs with label being 0. r.)r trivial_graphr)rr rr*rrrrrs rx&1 ins_del_scorecCsJt|tjs tj||d}t||d\}}}t||d}t|d||S)aDConstruct levenshtein graphs from symbols. See https://github.com/k2-fsa/k2/pull/828 for more details about levenshtein graph. Args: symbols: It can be one of the following types: - A list of list-of-integers, e..g, `[ [1, 2], [1, 2, 3] ]` - An instance of :class:`k2.RaggedTensor`. Must have `num_axes == 2` and with dtype `torch.int32`. ins_del_score: The score on the self loops arcs in the graphs, the main idea of this score is to set insertion and deletion penalty, which will affect the shortest path searching produre. device: Optional. It can be either a string (e.g., 'cpu', 'cuda:0') or a torch.device. By default, the returned FSA is on CPU. If `symbols` is an instance of :class:`k2.RaggedTensor`, the returned FSA will on the same device as `k2.RaggedTensor`. Returns: An FsaVec containing the returned levenshtein graphs, with "Dim0()" the same as "len(symbols)"(List[List[int]]) or "dim0"(k2.RaggedTensor). rTr.%__ins_del_score_offset_internal_attr_)rrrrlevenshtein_graphrr)rrr rr* score_offsetsrrrrr5s !  rrefshypshyp_to_ref_mapsorted_match_refcCst|dsJt|dsJ|ddtj||||d}t|}tj|dd}|dd|dd|jt|d8_|S) aGet the levenshtein alignment of two FsaVecs This function supports both CPU and GPU. But it is very slow on CPU. Args: refs: An FsaVec (must have 3 axes, i.e., `len(refs.shape) == 3`. It is the output Fsa of the :func:`levenshtein_graph`. hyps: An FsaVec (must have 3 axes) on the same device as `refs`. It is the output Fsa of the :func:`levenshtein_graph`. hyp_to_ref_map: A 1-D torch.Tensor with dtype torch.int32 on the same device as `refs`. Map from FSA-id in `hpys` to the corresponding FSA-id in `refs` that we want to get levenshtein alignment with. E.g. might be an identity map, or all-to-zero, or something the user chooses. Requires - `hyp_to_ref_map.shape[0] == hyps.shape[0]` - `0 <= hyp_to_ref_map[i] < refs.shape[0]` sorted_match_ref: If true, the arcs of refs must be sorted by label (checked by calling code via properties), and we'll use a matching approach that requires this. Returns: Returns an FsaVec containing the alignment information and satisfing `ans.Dim0() == hyps.Dim0()`. Two attributes named `ref_labels` and `hyp_labels` will be added to the returned FsaVec. `ref_labels` contains the aligned sequences of refs and `hyp_labels` contains the aligned sequences of hyps. You can get the levenshtein distance by calling `get_tot_scores` on the returned FsaVec. Examples: >>> hyps = k2.levenshtein_graph([[1, 2, 3], [1, 3, 3, 2]]) >>> refs = k2.levenshtein_graph([[1, 2, 4]]) >>> alignment = k2.levenshtein_alignment( refs, hyps, hyp_to_ref_map=torch.tensor([0, 0], dtype=torch.int32), sorted_match_ref=True) >>> alignment.labels tensor([ 1, 2, 0, -1, 1, 0, 0, 0, -1], dtype=torch.int32) >>> alignment.ref_labels tensor([ 1, 2, 4, -1, 1, 2, 4, 0, -1], dtype=torch.int32) >>> alignment.hyp_labels tensor([ 1, 2, 3, -1, 1, 3, 3, 2, -1], dtype=torch.int32) >>> -alignment.get_tot_scores( use_double_scores=False, log_semiring=False)) tensor([1., 3.]) r* hyp_labels)rXrYT)rwr ref_labelsr) r<rnrr[r~ryrrEr)rrrrlattice alignmentrrrlevenshtein_alignmentbs 9     rcCr})aCompute the union of a FsaVec. Caution: We require that every fsa in fsas is non-empty, i.e., contains at least two states Args: fsas: A FsaVec. That is, len(fsas.shape) == 3. Returns: A single Fsa that is the union of the input fsas. T)runionr"rrRrS)rrPrrLrUrrrrs  r)N)FF)TF)TN)F)T)FN)rF)Fr)rr)5typingrrrrr1rrrrropsr r intrr rkrr)r7rNrQboolr[rfr!rsrmryr&r~rrrrDeterminizeWeightPushingTypekNoWeightPushingrrrlrrrrrrrrrrrrrrrs\          "  _ S W V  B  ")   3; & 4 "  h 3 ] :  1 N