o GiB @sddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZdd lmZdd l mZGd d d eZd eedeedeeedeeeeffddZdS))Any)Dict)Iterator)List)Optional)Tuple)UnionN) RaggedArc)fsa_propertiesc@seZdZdZ  ddeejefdeeeje j fddfddZ dd e ddfd d Z dd e defddZdefddZdedeeeffddZ ddeedeeddfddZdededdfddZedefddZedefd d!Zedefd"d#Zede fd$d%Zedejfd&d'Zdedefd(d)Zdeddfd*d+Zde j fd,d-Zdejfd.d/Z de j fd0d1Z!de j fd2d3Z"de j fd4d5Z#d6e d7e dejfd8d9Z$d6e d7e dejfd:d;Z%d6e d7e dejfdd?Z'd6e d7e dejfd@dAZ(d6e d7e dejfdBdCZ)d6e d7e dejfdDdEZ*d6e d7e dejfdFdGZ+d6e d7e dejfdHdIZ,d6e dejfdJdKZ-dLe ddfdMdNZ.dOedPeddfdQdRZ/ddSdTZ0ddUdVZ1de fdWdXZ2de fdYdZZ3edej4fd[d\Z4d]eddfd^d_Z5dejfd`daZ6de7eeffdbdcZ8e9dde7eefddfdedfZ:dgeeej4fddfdhdiZ;ddjdkZe?eejffdodpZ@de>e?eeffdqdrZAede?edsffdtduZBe9dddgd fdvedwee dxeedyeeCedzeCed e ddfd{d|ZDe9dddgfdvedwee dxeedyeeCedzeCeddf d}d~ZEeFdeCdddfddZGdddZH ddede ddfddZIdS)Fsaa This class represents a single fsa or a vector of fsas. When it denotes a single FSA, its attribute :attr:`shape` is a tuple containing two elements `(num_states, None)`; when it represents a vector of FSAs it is a tuple with three elements `(num_fsas, None, None)`. CAUTION: It's possible for a vector of FSAs to have zero or one elements. An instance of FSA has the following attributes: arcs You will NOT use it directly in Python. It is an instance of `_k2.RaggedArc` with only one method `values()` which returns a 2-D `torch.Tensor` of dtype `torch.int32` with 4 columns. Its number of rows indicates the number of arcs in the FSA. The first column represents the source states, second column the destination states, third column the labels and the fourth column is the score. Note that the score is actually a float number but it is **reinterpreted** as an integer. scores A 1-D `torch.Tensor` of dtype `torch.float32`. It has as many entries as the number of arcs representing the score of every arc. labels 1-D `torch.Tensor` of dtype `torch.int32`. It has as many entries as the number of arcs representing the label of every arc. It MAY have the following attributes: symbols An instance of `k2.SymbolTable`. It maps an entry in `labels` to an integer and vice versa. It is used for visualization only. aux_labels A 1-D `torch.Tensor` of dtype `torch.int32` or a ragged tensor with type `k2.RaggedTensor`. It contains auxiliary labels per arc. If it's a tensor, `aux_labels.numel()` equals to the number of arcs. if it's `k2.RaggedTensor`, then `aux_labels.dim0()` equals to the number of arcs. aux_symbols An instance of `k2.SymbolTable`. It maps an entry in `aux_labels` to an integer and vice versa. properties An integer that encodes the properties of the FSA. It is accessed as fsa.properties (read-only!) It MAY have other attributes that set by users. Tensor attributes should have the same 1st dimension as the number of arcs in the FSA, Ragged attributes should have the same `dim0` as the number of arcs in the FSA. CAUTION: When an attribute is an instance of `torch.Tensor`, its `shape[0]` has to be equal to the number arcs. Otherwise, an assertion error will be thrown. When an attribute is an instance of `k2.RaggedTensor`, its `dim0` has to be equal to the number arcs. Otherwise, an assertion error will be thrown. NOTE: `symbols` and `aux_symbols` are symbol tables, while `labels` is instances of `torch.Tensor` and `aux_labels` is instances of `torch.Tensor` or `k2.RaggedTensor`. Implementation note: most of this class's attributes are not real attributes in the object's dict; the real attributes are `arcs`, `_non_tensor_attr`, `_tensor_attr`, `_properties`, `_cache`. Narcs aux_labelsreturncCst|tjr t|}t|tsJ||jd<||jd<dD]}t|j|<qt|j dddf|j d<|j dddf|j d<|j dj |_ |durbt|tjr_|tj|_n||_|j}dS) aaBuild an Fsa from a tensor with optional aux_labels. It is useful when loading an Fsa from file. Args: arcs: When the `arcs` is an instance of `torch.Tensor`, it is a torch tensor of dtype `torch.int32` with 4 columns. Each row represents an arc. Column 0 is the src_state, column 1 the dest_state, column 2 the label, and column 3 the score. When the `arcs` is an instance of `_k2.RaggedArc`, it is a Ragged containing `_k2.Arc` returned by internal functions (i.e. C++/CUDA functions) or got from other Fsa object by `fsa.arcs`. Caution: Scores are floats and their binary pattern is **reinterpreted** as integers and saved in a tensor of dtype `torch.int32`. aux_labels: Optional. If not None, it associates an aux_label with every arc, so it has as many rows as `tensor`. It is a 1-D tensor of dtype `torch.int32` or `k2.RaggedTensor` whose `dim0` equals to the number of arcs. properties: Tensor properties if known (should only be provided by internal code, as they are not checked; intended for use by :func:`clone`) Returns: An instance of Fsa. r _properties) _tensor_attr_non_tensor_attr_cacheNscoreslabels) isinstancetorchTensor_k2fsa_from_tensorr __dict__dictas_floatr valuesr_versionlabels_versiontoint32r properties)selfr r r$name_r(:/home/ubuntu/.local/lib/python3.10/site-packages/k2/fsa.py__init__ws (   7"  z Fsa.__init__T scores_onlycCs||dur t|jd<dStd}g}|jdD] }||r$||qd|jdvr1|d|D]}|jd|=q3dS)a}Intended for internal use only so its name begins with an underline. Also, it changes `self` in-place. Currently, it is used only when the `scores` field are re-assigned. Args: scores_only: It True, it invalidates only cached entries related to scores. If False, the whole cache is invalidated. Frzscore|arc_cdf|arc_post entering_arcsN)rrrecompilesearchappend)r%r+pattern to_removekeyr(r(r)_invalidate_cache_s    zFsa._invalidate_cache_Fopenfstc sg}g}t|jddD]!\}}t|tjr"|jtjkr"||q t|tj r-||q |j dkrBdt j |j |||d}nAd}t|jdD]7}|j d|\}|jd|dt|d t j ||fd d |Dfd d |Dd7}qK|d t |jd7}|jddD]\}}d} || |d|7}q|D]\}}|dkrqd} || |d|7}q|S)NFinclude_scoresrzk2.Fsa: )r5 extra_labels ragged_labelsz k2.FsaVec: rzFsaVec[z]: cg|]}|qSr(r(.0xendstartr(r) (zFsa.to_str..cr:r(r(r;r>r(r)rA)rBzproperties_str = . z: labels_sym)sortednamed_tensor_attrrrrdtyper#r0k2 RaggedTensorr num_axesr fsa_to_strrangeshapeindexrstrfsa_properties_as_strrnamed_non_tensor_attr) r%r5r8r9r&valueansi ragged_arcsepr(r>r)to_strsH      z Fsa.to_strcCs |jddS)zaReturn a string representation of this object For visualization and debug only. Fr5)rXr%r(r(r)__str__7s z Fsa.__str__attribute_namecCs,t||dd}|dks|dksJd|S)aReturn the filler value associated with attribute names. This is 0 unless otherwise specified, but you can override this by for example, doing:: fsa.foo_filler = -1 which will mean the "filler" for attribute fsa.foo is -1; and this will get propagated when you do FSA operations, like any other non-tensor attribute. The filler is the value that means "nothing is here" (like epsilon). Caution:: you should use a value that is castable to float and back to integer without loss of precision, because currently the `default_value` parameter of `index_select` in ./ops.py is a float. _fillerrr z(you cannot set the filler for aux_labels)getattr)r%r\rTr(r(r) get_filler>s zFsa.get_fillerfilenametitleDigraphc Cstjj||d}tj|\}}|dks|ddkr!td||rOddl}| }|j d||ddd d }t ||Wd|S1sJwY|S) ap Render FSA as an image via graphviz, and return the Digraph object; and optionally save to file `filename`. `filename` must have a suffix that graphviz understands, such as `pdf`, `svg` or `png`. Note: You need to install graphviz to use this function:: pip install graphviz Args: filename: Filename to (optionally) save to, e.g. 'foo.png', 'foo.svg', 'foo.png' (must have a suffix that graphviz understands). title: Title to be displayed in image, e.g. 'A simple FSA example' )rarrCz9Filename needs to have a suffix like .png, .pdf, .svg: {}NtempT)r` directoryformatcleanup) rIutilsto_dotospathsplitext ValueErrorrgtempfileTemporaryDirectoryrendershutilmove) r%r`radigraphr' extensionrotmp_dirtemp_fnr(r(r)drawVs(   zFsa.drawr&rScCsr|dvsJt|tjr{|jd|jjdksJ|j|jks#J|dkrR|jtjks/J||jdddf<|j dj |_ t |jdd|jd<|jdS||j |<|dkry|jtjkscJt ||jdddf<|dSdSt|tjr|j|jjdksJd |jd |jjd|j|jksJ|j|jf||j |<dS||j|<dS) a Caution: We save a reference to `value`. If you need to change `value` afterwards, please consider passing a copy of it. Args: name: Name of the attribute. value: Value of the attribute. )rrr rrr$rrNrrrrz value.dim0: z , shape[0]: )rrrrNr rdevicerHr#rr r!rfix_final_labelsrr$float32as_intdetachr4rIrJdim0rr%r&rSr(r(r) __setattr__~s2      zFsa.__setattr__cCs |jS)z/Return the number of arcs in this Fsa. )r num_elementsrZr(r(r)num_arcss z Fsa.num_arcscCs|jdd}|dur|jj|jkrtd|S|jdkr&t |j}nt |j}||jd<|t j @dkrGt d|t |t|j|S)NrzThe fsa attribute (labels) has been inappropriately modified like: fsa.labels[xxx] = yyy The correct way should be like: labels = fsa.labels labels[xxx] = yyy fsa.labels = labelsrrez7Fsa is not valid, properties are: {} = {}, arcs are: {})rgetrr r! RuntimeErrorr rKrget_fsa_basic_propertiesget_fsa_vec_basic_propertiesr VALIDrnrgrXrP)r%r$r(r(r)r$s&    zFsa.propertiescC t|jSN)rrQr$rZr(r(r)properties_strs zFsa.properties_strcC|jjSr)r requires_gradrZr(r(r)rzFsa.requires_gradcCrr)rgradrZr(r(r)rrzFsa.gradcCsJ||jvr |j|S||jvr|j|S||jvr|j|Std|)a Note: for attributes that exist as properties, e.g. self.labels, self.properties, self.requires_grad, we won't reach this code because Python checks the class dict before calling getattr. The same is true for instance attributes such as self.{_tensor_attr,_non_tensor_attr,_cache,_properties} The 'virtual' members of this class are those in self._tensor_attr and self._non_tensor_attr. zUnknown attribute )rrrAttributeErrorr%r&r(r(r) __getattr__s     zFsa.__getattr__cCsr|tjvr |dks J||jvsJ||jvr|j|=dS||jvr(|j|=dS||jvr3|j|=dStd|)NrzNo such attribute in Fsa: )r rrrrrrr(r(r) __delattr__s       zFsa.__delattr__cC0d|j}}||vrtj|jdd||<||S)zGet (and compute if necessary) cached property `state_batches`. For use by internal k2 code. Used in many algorithms. state_batchesT) transpose)rrget_state_batchesr r%r&cacher(r(r)_get_state_batches zFsa._get_state_batchescCr)zGet (and compute if necessary) cached property self.dest_states. For use by internal k2 code, relates to best-path. dest_statesT)as_idx01)rrget_dest_statesr rr(r(r)_get_dest_statesrzFsa._get_dest_statescC2d|j}}||vrt|j|||<||S)zGet (and compute if necessary) cached property self.incoming_arcs. For use by internal k2 code, relates to best-path incoming_arcs)rrget_incoming_arcsr rrr(r(r)_get_incoming_arcss zFsa._get_incoming_arcscCs:d|j}}||vrtj|j||d||<||S)zGet (and compute if necessary) cached property `self.entering_arc_batches`. For use by internal k2 code, used in many algorithms. entering_arc_batches)rr)rrget_entering_arc_index_batchesr rrrr(r(r)_get_entering_arc_batches%s  zFsa._get_entering_arc_batchescCr)zGet (and compute if necessary) cached property `self.leaving_arc_batches`. For use by internal k2 code, used in many algorithms. leaving_arc_batches)rrget_leaving_arc_index_batchesr rrr(r(r)_get_leaving_arc_batches3s  zFsa._get_leaving_arc_batchesuse_double_scores log_semiringcCsdd|rdnd|r dnd}|j}||vr.|||}|r tjntj}||j|d}|||<||S)Narc_cdf_double_float_logtropical)fsasarc_post)r _get_arc_postrget_arc_cdf_doubleget_arc_cdf_floatr )r%rrr&rrfuncarc_cdfr(r(r) _get_arc_cdf?s   zFsa._get_arc_cdfcCsrd|rdnd|r dnd}|j}||vr5|rtj}ntj}||j|||d\||<}|s5||d<||S)a}Get (and compute if necessary) cached property `self.forward_scores_xxx_yyy` (where xxx indicates float-type and yyy indicates semiring). For use by internal k2 code; returns the total score from start-state to each state. Not differentiable; see :func:`get_forward_scores` which is the differentiable version. Args: use_double_scores: True to use `double precision` floating point. False to use `single precision`. log_semiring: True to use log semiring (log-sum), false to use tropical (i.e. max on scores). forward_scores_rrrr)rrrr,)rrget_forward_scores_doubleget_forward_scores_floatr rr)r%rrr&rrr,r(r(r)_get_forward_scoresMs&  zFsa._get_forward_scorescCtjj||||j}|S)a}Compute forward-scores, i.e. total weight (or best-path weight) from start state to each state. Supports autograd. Args: use_double_scores: if True, use double precision. log_semiring: if True, use log semiring, else tropical. Returns: A torch.Tensor with shape equal to (num_states,) )rIautograd_GetForwardScoresFunctionapplyr)r%rrforward_scoresr(r(r)get_forward_scoresq zFsa.get_forward_scorescCshd|rdnd|r dnd}|j}||vr0|durtj}ntj}|||}||j|}|||<||S)aCompute total-scores (one per FSA) as the best-path score. This version is not differentiable; see also :func:`get_tot_scores` which is differentiable. Args: use_double_scores: If True, use `double precision` floating point; false; else single precision. log_semiring: True to use log semiring (log-sum), false to use tropical (i.e. max on scores). tot_scores_rrrrT)rrget_tot_scores_doubleget_tot_scores_floatrr )r%rrr&rrr total_scoresr(r(r)_get_tot_scoress    zFsa._get_tot_scorescCr)aCompute total-scores (one per FSA) as the best-path score. This version is differentiable. Args: use_double_scores: True to use `double precision` floating point; False to use `single precision`. log_semiring: True to use log semiring (log-sum), false to use tropical (i.e. max on scores). )rIr_GetTotScoresFunctionrr)r%rr tot_scoresr(r(r)get_tot_scoress zFsa.get_tot_scoresc Csnd|rdnd|r dnd}|j}||vr3|rtj}ntj}|}|}||j|||d}|||<||S)aOCompute backward-scores, i.e. total weight (or best-path weight) from each state to the final state. For internal k2 use. Not differentiable. See also :func:`get_backward_scores` which is differentiable. Args: use_double_scores: True to use `double precision` floating point. False to use `single precision`. log_semiring: True to use log semiring (log-sum), false to use tropical (i.e. max on scores). Returns: A torch.Tensor with shape equal to (num_states,) backward_scores_rrrr)rrr)rrget_backward_scores_doubleget_backward_scores_floatrrr ) r%rrr&rrrrbackward_scoresr(r(r)_get_backward_scoress&  zFsa._get_backward_scorescCr)aCompute backward-scores, i.e. total weight (or best-path weight) from each state to the final state. Supports autograd. Args: use_double_scores: if True, use double precision. log_semiring: if True, use log semiring, else tropical. Returns: A torch.Tensor with shape equal to (num_states,) )rIr_GetBackwardScoresFunctionrr)r%rrrr(r(r)get_backward_scoresrzFsa.get_backward_scoresc Csrd|rdnd|r dnd}|j}||vr5|||}|||}|r&tjntj}||j||d}|||<||S)aCompute scores on arcs, representing log probabilities; with log_semiring=True you could call these log posteriors, but if log_semiring=False they can only be interpreted as the difference between the best-path score and the score of the best path that includes this arc. This version is not differentiable; see also :func:`get_arc_post`. Args: use_double_scores: if True, use double precision. log_semiring: if True, use log semiring, else tropical. Returns: A torch.Tensor with shape equal to (num_arcs,) and non-positive elements. arc_post_rrrr)rrr)rrrrget_arc_post_doubleget_arc_post_floatr ) r%rrr&rrrrrr(r(r)rs.  zFsa._get_arc_postcCs6|||}|||}tjj||||j||}|S)agCompute scores on arcs, representing log probabilities; with log_semiring=True you could call these log posteriors, but if log_semiring=False they can only be interpreted as the difference between the best-path score and the score of the best path that includes this arc. This version is differentiable; see also :func:`_get_arc_post`. Caution: Because of how the autograd mechanics works and the need to avoid circular references, this is not cached; it's best to store it if you'll need it multiple times. Args: use_double_scores: if True, use double precision. log_semiring: if True, use log semiring, else tropical. Returns: A torch.Tensor with shape equal to (num_arcs,) and non-positive elements. )rrrIr_GetArcPostFunctionrr)r%rrrrrr(r(r) get_arc_posts zFsa.get_arc_postcCs(d|j}}||vr||d||S)zCompute, for each state, the index of the best arc entering it. For internal k2 use. Args: use_double_scores: True to use `double precision` floating point. False to use `single precision`. r,F)rr)r%rr&rr(r(r)_get_entering_arcs;s  zFsa._get_entering_arcsrcCs|j||S)aaChange if autograd should record operations on this FSA: Sets the `scores`'s requires_grad attribute in-place. Returns this FSA. You can test whether this object has the requires_grad property true or false by accessing :py:attr:`requires_grad` (handled in :func:`__getattr__`). Caution: This is an **in-place** operation as you can see that the function name ends with `_`. Args: requires_grad: If autograd should record operations on this FSA or not. Returns: This FSA itself. )rrequires_grad_)r%rr(r(r)rKs zFsa.requires_grad_src_name dest_namec CsL||ksJ||jvs|dksJz!t||}|dkr|}t||||dkr1|dkr1|j|=WntyJ}z td|dt|d}~wwt|}t|}g}t|j D]-\}}|d||kr}|dkr}|||d} | || |fq\|d||kr|j |=q\|D]\}} }||j | <|j |=q|dkr|j j |_|S)aRename a tensor attribute (or, as a special case 'labels'), and also rename non-tensor attributes that are associated with it, i.e. that have it as a prefix. Args: src_name: The original name, exist as a tensor attribute, e.g. 'aux_labels', or, as a special case, equal 'labels'; special attributes 'labels' and 'scores' are allowed but won't be deleted. dest_name: The new name, that we are renaming it to. If it already existed as a tensor attribute, it will be rewritten; and any previously existing non-tensor attributes that have this as a prefix will be deleted. As a special case, may equal 'labels'. Returns: Return `self`. Note:: It is OK if src_name and/or dest_name equals 'labels' or 'scores', but these special attributes won't be deleted. rrzName z5 does not exist as a tensor attribute: exception was Nr!)rr^clonesetattrKeyErrorrnrPlenlistritemsr0rr r!) r%rrrSe src_name_len dest_name_lento_mover&new_namer(r(r)rename_tensor_attribute_ds@       zFsa.rename_tensor_attribute_cCsnt|ds tdt|jtjstd|dd|dd|ddt|j dd|j d<|j |S)aSwap the `labels` and `aux_labels`. If there are symbol tables associated with `labels` and `aux_labels`, they are also swapped. It is an error if the FSA contains no `aux_labels`. CAUTION: The function name ends with an underscore which means this is an **in-place** operation. Returns: Return `self`. r z5invert_ cannot be called on acceptors (no aux_labels)zFcurrent invert_ method only supports case where aux_labels is a tensorr__tempNr) hasattrrrr rrrrrzr rr$rZr(r(r)invert_s     z Fsa.invert_cCs |S)aSwap the `labels` and `aux_labels`. If there are symbol tables associated with `labels` and `aux_labels`, they are also swapped. It is an error if the FSA contains no `aux_labels`. Returns: Return a new Fsa. )rrrZr(r(r)inverts z Fsa.invertcC |jjdkS)zsReturn true if this FSA is on CPU. Returns: True if the FSA is on CPU; False otherwise. cpurytyperZr(r(r)is_cpu z Fsa.is_cpucCr)zsReturn true if this FSA is on GPU. Returns: True if the FSA is on GPU; False otherwise. cudarrZr(r(r)is_cudarz Fsa.is_cudacCrr)rryrZr(r(r)ryrz Fsa.devicerUc Cst|jdks Jd|kr|jdksJJ|jd|\}}||jd}t|}|jddD])\}}t|tj rKt |||||q6t|t j sSJt |||j d||dq6|D] \}}t |||qdt j||j|||S)zGet the i-th FSA. Caution: `self` has to be an FsaVec, i.e. len(self.shape) == 3 Args: i: The i-th FSA to select. 0 <= i < self.arcs.dim0(). Returns: The i-th FSA. Note it is a single FSA. rFr6)axisbeginr?)rrNr rOrr rGrrrrrIrJarangerRautograd_utilsphantom_set_scores_tor)r%rUrVr@r?out_fsar&rSr(r(r) __getitem__s$ "  zFsa.__getitem__cCr)aReturn the core part of the Fsa (the arcs) serialized to a Tensor of int32 type, with shape (num_arcs, 4); the floats are reinterpreted as int32 and will appear as garbage if printed. This can be passed to the constructor, along with the aux_labels if present, to reconstruct this object. A more convenient way to serialize a Tensor is to use :func:`as_dict` and :func:`from_dict` )r fsa_to_tensorr rZr(r(r)arcs_as_tensors zFsa.arcs_as_tensorcCsRt}t|j|d<|jddD]\}}|||<q|D]\}}|||<q|S)a"Convert this Fsa to a dict (probably for purposes of serialization , e.g., torch.save). Caution: `self.requires_grad` attribute is not saved. Returns: A `dict` that can be used to reconstruct this FSA by using `Fsa.from_dict`. r Fr6)rrrr rGrRr%rTr&rSr(r(r)as_dict#s   z Fsa.as_dictdict_incCsDt|d|ddd}|D]\}}|dvrqt|||q|S)Nr r )r )r r )r rrr)clsrfsar3rSr(r(r) from_dict8s z Fsa.from_dictrycCst|tr t|}|jdvsJ||jjkr|St|j||j d}|j ddD] \}}t ||||q*| D] \}}t |||q| WSt ye|rVdnd}t d|d|d|w) aCreate an Fsa from a string in the k2 or OpenFst format. (See also :func:`from_openfst`). The given string `s` consists of lines with the following format:: src_state dest_state label [aux_label1 aux_label2...] [score] The line for the final state consists of only one field:: final_state Note: Fields are separated by space(s), tab(s) or both. The `score` field is a float, while other fields are integers. Caution: The first column has to be non-decreasing. Caution: The final state has the largest state number. There is **ONLY** ONE final state. All arcs that are connected to the final state have label -1. If there are aux_labels, they are also -1 for arcs entering the final state. Note: At most one of `acceptor`, `num_aux_labels`, and `aux_label_names` must be supplied; if none are supplied, acceptor format is assumed. Args: s: The input string. Refer to the above comment for its format. acceptor: Set to true to denote acceptor format which is num_aux_labels == 0, or false to denote transducer format (i.e. num_aux_labels == 1 with name 'aux_labels'). num_aux_labels: The number of auxiliary labels to expect on each line (in addition to the 'acceptor' label; is 1 for traditional transducers but can be any non-negative number. The names of the aux_labels default to 'aux_labels' then 'aux_labels2', 'aux_labels3' and so on. aux_label_names: If provided, the length of this list dictates the number of aux_labels and this list dictates their names. ragged_label_names: If provided, expect this number of ragged labels, in the order of this list. It is advisable that this list be in alphabetical order, so that the format when we write back to a string will be unchanged. openfst: If true, will expect the OpenFST format (costs not scores, i.e. negated; final-probs rather than final-state specified). rYNrzin the OpenFst format rcz!The following is not a valid Fsa z(with num_aux_labels=z): ) get_aux_label_inforr fsa_from_strr rMrNrzip Exceptionrn)rrrrrrr5num_ragged_labelsr r r9rTrUr&rSor(r(r)from_strs2 >   z Fsa.from_strcCstj|||||ddS)a Create an Fsa from a string in OpenFST format (or a slightly more general format, if num_aux_labels > 1). See also :func:`from_str`. The given string `s` consists of lines with the following format:: src_state dest_state label [aux_label1 aux_label2...] [cost] (the cost defaults to 0.0 if not present). The line for the final state consists of two fields:: final_state [cost] Note: Fields are separated by space(s), tab(s) or both. The `cost` field is a float, while other fields are integers. There might be multiple final states. Also, OpenFst may omit the cost if it is 0.0. Caution: We use `cost` here to indicate that its value will be negated so that we can get `scores`. That is, `score = -1 * cost`. Note: At most one of `acceptor`, `num_aux_labels`, and `aux_label_names` must be supplied; if none are supplied, acceptor format is assumed. Args: s: The input string. Refer to the above comment for its format. acceptor: Set to true to denote acceptor format which is num_aux_labels == 0, or false to denote transducer format (i.e. num_aux_labels == 1 with name 'aux_labels'). num_aux_labels: The number of auxiliary labels to expect on each line (in addition to the 'acceptor' label; is 1 for traditional transducers but can be any non-negative number. aux_label_names: If provided, the length of this list dictates the number of aux_labels. By default the names are 'aux_labels', 'aux_labels2', 'aux_labels3' and so on. ragged_label_names: If provided, expect this number of ragged labels, in the order of this list. It is advisable that this list be in alphabetical order, so that the format when we write back to a string will be unchanged. TrY)r r)rrrrrrr(r(r) from_openfsts 8zFsa.from_openfstrcCs t|S)zCreate an FsaVec from a list of FSAs. See also :func:`k2.create_fsa_vec`. This function is just a wrapper of that function. )rIcreate_fsa_vec)rr(r(r) from_fsasZs z Fsa.from_fsascCsp|jdksJ|jtjksJ||jksJt|j |j |}|j dd}|j |jj |_dS)aNormalize the given `scores` and assign it to `self.scores`. Args: scores: Tensor of scores of dtype torch.float32, and shape equal to `self.scores.shape` (one axis). Will be normalized so the sum, after exponentiating, of the scores leaving each state that has at least one arc leaving it is 1. Caution: The function name ends with an underline indicating this function will modify `self` **in-place**. reT)use_logN)ndimrHrr{numelrrIrJr rNr"ry normalizer)r%r ragged_scoresr(r(r)set_scores_stochastic_cs zFsa.set_scores_stochastic_ remove_epscCst||sJt||}t|tjsJ|jdksJ|jtjks#Jtj j | dd |j }t||}|rA|jdd}t||||S)aConvert the attribute given by `name` from a 1-D torch.tensor to a k2.RaggedTensor. Caution: This function ends with an underscore, meaning it changes the FSA **in-place**. Args: name: The attribute name. This attribute is expected to be a 1-D tensor with dtype torch.int32. remove_eps: True to remove 0s in the resulting ragged tensor. Returns: Return self. re)r~dim1r)target)rr^rrrrrHr#rIraggedregular_ragged_shaperr"ryrJ contiguousremove_values_eqr)r%r&rrSrN new_valuer(r(r)convert_attr_to_ragged_}s    zFsa.convert_attr_to_ragged_)NN)T)Fr)rr )rN)J__name__ __module__ __qualname____doc__rrrr rrIrJr*boolr4rPrXr[intfloatr_rxrrpropertyrr$rrrrrrrrrrrrrrrrrrrrrrrrrrryrrrr classmethodrr"rr}rrrGrRrNrrr staticmethodrrr!r(r(r(r)r (s6Q  {!$  (2      $    '  $ & 7 ; "  &      Q  ; r rrrrcCs|dur|dur |dusJ|rdgfSddgfS|dur)|dus#Jt||fS|durT|dks3Jg}|dkr>|dtd|D] }|d|dqC||fSdgfS)aGiven either acceptor or num_aux_labels or aux_label_names, at most one of which should be supplied, returns a pair (num_aux_labels, aux_label_names) specifying the number of auxiliary labels and the names to use for them. Args: acceptor: None, or a bool; False means no aux_labels and True means aux_label with name 'aux_label'. num_aux_labels: None, or a number >= 0 aux_label_names: None, or a list of names, such as ['aux_labels', 'aux_labels2'] Returns: Returns a tuple (num_aux_labels, aux_label_names). out from the other. If all inputs are None, we assume there are no aux-labels and return (0, []). Nrrer )rr0rM)rrrrUr(r(r)r s    r )typingrrrrrrrrkr-rrrrI k2.raggedrr r objectr r&r'rPr r(r(r(r)sB