AVhdZddlZddlmZddlmZddlmZddlmZddlmZddlm Z dd lm Z dd lm Z dd lm Z dd l mZdd l mZddl mZddl mZddl mZddl mZddl mZddl mZddl mZddl mZddl mZddl mZddlmZddlmZddlmZddlmZddl m!Z!dZ"dZ#dZ$d Z%d!Z&d"Z'e!d#g$ejP dKd%Z) dLd&Z*d'Z+e jXd(d)Z-e jXd*d+Z.e!d,ejP dMd-Z/e!d.g$ejP dNd/Z0e!d.d0g$ejP dOd1Z1e jdd2e jdd3d4Z3d5Z4d6Z5d7Z6d8Z7dPd9Z8d:Z9d;Z:d<Z;d=Z<e!d>g$ejP dQd?Z=e!d#g$ejP dQd@Z> dRdAZ?e!dBejPdPdCZ@dDZAe!dEejPdPdFZBdGZCdHZDdSdIZEdJZFy)Tz7CTC (Connectionist Temporal Classification) Operations.N)context) def_function) constant_op)device)dtypes)function)ops) sparse_tensor) tensor_shape) array_ops)array_ops_stack)custom_gradient)functional_ops) gen_array_ops) gen_ctc_ops) inplace_ops) linalg_ops)map_fn)math_ops)nn_ops) sparse_ops) _BroadcastMul) deprecation)dispatch)nest) tf_exportapi_implementsapi_preferred_deviceCPUGPUctjj}|ytjj |j S)zCParses the current context and returns the device type, eg CPU/GPU.N)r device_namer DeviceSpec from_string device_type)current_devices M/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/ctc_ops.py_get_context_device_typer(6s:??$00.     & &~ 6 B BBcNt|t|i}tj||dS)NF)funcexperimental_attributes autograph)_DEFUN_API_NAME_ATTRIBUTE_DEFUN_DEVICE_ATTRIBUTErr)unique_api_namepreferred_devicer+function_attributess r'_generate_defun_backendr3>s4/    )< OOr)z nn.ctc_loss)v1c *t||||||||d S)aComputes the CTC (Connectionist Temporal Classification) Loss. This op implements the CTC loss as presented in (Graves et al., 2006). Input requirements: ``` sequence_length(b) <= time for all b max(labels.indices(labels.indices[:, 1] == b, 2)) <= sequence_length(b) for all b. ``` Notes: This class performs the softmax operation for you, so inputs should be e.g. linear projections of outputs by an LSTM. The `inputs` Tensor's innermost dimension size, `num_classes`, represents `num_labels + 1` classes, where num_labels is the number of true labels, and the largest value `(num_classes - 1)` is reserved for the blank label. For example, for a vocabulary containing 3 labels `[a, b, c]`, `num_classes = 4` and the labels indexing is `{a: 0, b: 1, c: 2, blank: 3}`. Regarding the arguments `preprocess_collapse_repeated` and `ctc_merge_repeated`: If `preprocess_collapse_repeated` is True, then a preprocessing step runs before loss calculation, wherein repeated labels passed to the loss are merged into single labels. This is useful if the training labels come from, e.g., forced alignments and therefore have unnecessary repetitions. If `ctc_merge_repeated` is set False, then deep within the CTC calculation, repeated non-blank labels will not be merged and are interpreted as individual labels. This is a simplified (non-standard) version of CTC. Here is a table of the (roughly) expected first order behavior: * `preprocess_collapse_repeated=False`, `ctc_merge_repeated=True` Classical CTC behavior: Outputs true repeated classes with blanks in between, and can also output repeated classes with no blanks in between that need to be collapsed by the decoder. * `preprocess_collapse_repeated=True`, `ctc_merge_repeated=False` Never learns to output repeated classes, as they are collapsed in the input labels before training. * `preprocess_collapse_repeated=False`, `ctc_merge_repeated=False` Outputs repeated classes with blanks in between, but generally does not require the decoder to collapse/merge repeated classes. * `preprocess_collapse_repeated=True`, `ctc_merge_repeated=True` Untested. Very likely will not learn to output repeated classes. The `ignore_longer_outputs_than_inputs` option allows to specify the behavior of the CTCLoss when dealing with sequences that have longer outputs than inputs. If true, the CTCLoss will simply return zero gradient for those items, otherwise an InvalidArgument error is returned, stopping training. Args: labels: An `int32` `SparseTensor`. `labels.indices[i, :] == [b, t]` means `labels.values[i]` stores the id for (batch b, time t). `labels.values[i]` must take on values in `[0, num_labels)`. See `core/ops/ctc_ops.cc` for more details. inputs: 3-D `float` `Tensor`. If time_major == False, this will be a `Tensor` shaped: `[batch_size, max_time, num_classes]`. If time_major == True (default), this will be a `Tensor` shaped: `[max_time, batch_size, num_classes]`. The logits. sequence_length: 1-D `int32` vector, size `[batch_size]`. The sequence lengths. preprocess_collapse_repeated: Boolean. Default: False. If True, repeated labels are collapsed prior to the CTC calculation. ctc_merge_repeated: Boolean. Default: True. ignore_longer_outputs_than_inputs: Boolean. Default: False. If True, sequences with longer outputs than inputs will be ignored. time_major: The shape format of the `inputs` Tensors. If True, these `Tensors` must be shaped `[max_time, batch_size, num_classes]`. If False, these `Tensors` must be shaped `[batch_size, max_time, num_classes]`. Using `time_major = True` (default) is a bit more efficient because it avoids transposes at the beginning of the ctc_loss calculation. However, most TensorFlow data is batch-major, so by this function also accepts inputs in batch-major form. logits: Alias for inputs. Returns: A 1-D `float` `Tensor`, size `[batch]`, containing the negative log probabilities. Raises: TypeError: if labels is not a `SparseTensor`. References: Connectionist Temporal Classification - Labeling Unsegmented Sequence Data with Recurrent Neural Networks: [Graves et al., 2006](https://dl.acm.org/citation.cfm?id=1143891) ([pdf](http://www.cs.toronto.edu/~graves/icml_2006.pdf)) F) use_cudnn)_ctc_loss_impl)labelsinputssequence_lengthpreprocess_collapse_repeatedctc_merge_repeated!ignore_longer_outputs_than_inputs time_majorlogitss r'ctc_lossr@Gs-b   "'   r)c t|tjs$td|dt |j t jd|d|}tj|d}|stj|gd}|j} | tjtjfvr$t!j"|tj$}|rt&j(} nt&j*} | ||j,|j.||||\} } | tjtjfvrt!j"| | } | S)NzAExpected argument `labels` to be a SparseTensor. Received labels=z of type: r?r9namer)r;r<r=) isinstancer SparseTensor TypeErrortype__name__rdeprecated_argument_lookupr convert_to_tensorr transposedtyperfloat16bfloat16rcastfloat32r ctc_loss_v2r@indicesvalues) r8r9r:r;r<r=r>r?r6 orig_dtype ctc_loss_funcloss_s r'r7r7s+ FM66 7 ''-hjF|,,-/ 00  1 1(FH28 :&  h 7&    3F||*FNNFOO44 ]]66>> 2F++M((M   nn mm#?+(I K'$FNNFOO44 ==z *D +r)cjtj|jdd}t||dddgS)NrEzCurrently there is no way to take the second derivative of ctc_loss due to the fused implementation's interaction with tf.gradients())message)r prevent_gradientoutputsr)op grad_lossrZgrad_without_gradients r'_CTCLossGradImplrbs>$44jjm  #8 94t LLr)CTCLossct|||S)zThe derivative provided by CTC Loss. Args: op: the CTCLoss op. grad_loss: The backprop for cost. Returns: The CTC Loss gradient. rbr_r`rZs r' _CTCLossGradrg  "i ++r) CTCLossV2ct|||S)zThe derivative provided by CTC Loss V2. Args: op: the CTCLossV2 op. grad_loss: The backprop for cost. Returns: The CTC Loss V2 gradient. rerfs r'_CTCLossV2Gradrkrhr)znn.ctc_greedy_decodercvtj||||}|\}}}}tj|||g|fS)a Performs greedy decoding on the logits given in input (best path). Given a tensor as `inputs`, the `blank_index` parameter defines the class index of the blank symbol. For example: If `blank_index` is equal to 1: >>> inf = float("inf") >>> logits = tf.constant([[[ 0., -inf, -inf], ... [ -2.3, -inf, -0.1]], ... [[ -inf, -0.5, -inf], ... [ -inf, -inf, -0.1]], ... [[ -inf, -inf, -inf], ... [ -0.1, -inf, -2.3]]]) >>> seq_lens = tf.constant([2, 3]) >>> outputs = tf.nn.ctc_greedy_decoder( ... logits, ... seq_lens, ... blank_index=1) Notes: - Unlike `ctc_beam_search_decoder`, `ctc_greedy_decoder` considers blanks as regular elements when computing the probability of a sequence. - Default `blank_index` is `(num_classes - 1)`, unless overriden. If `merge_repeated` is `True`, merge repeated classes in output. This means that if consecutive logits' maximum indices are the same, only the first of these is emitted. The sequence `A B B * B * B` (where '*' is the blank label) becomes * `A B B B` if `merge_repeated=True`. * `A B B B B` if `merge_repeated=False`. Args: inputs: 3-D `float` `Tensor` sized `[max_time, batch_size, num_classes]`. The logits. sequence_length: 1-D `int32` vector containing sequence lengths, having size `[batch_size]`. merge_repeated: Boolean. Default: True. blank_index: (Optional). Default: `num_classes - 1`. Define the class index to use for the blank label. Negative values will start from num_classes, ie, -1 will reproduce the ctc_greedy_decoder behavior of using num_classes - 1 for the blank symbol, which corresponds to the default. Returns: A tuple `(decoded, neg_sum_logits)` where decoded: A single-element list. `decoded[0]` is an `SparseTensor` containing the decoded outputs s.t.: `decoded.indices`: Indices matrix `(total_decoded_outputs, 2)`. The rows store: `[batch, time]`. `decoded.values`: Values vector, size `(total_decoded_outputs)`. The vector stores the decoded classes. `decoded.dense_shape`: Shape vector, size `(2)`. The shape values are: `[batch_size, max_decoded_length]` neg_sum_logits: A `float` matrix `(batch_size x 1)` containing, for the sequence found, the negative of the sum of the greatest logit at each timeframe. )merge_repeated blank_index)rctc_greedy_decoderr rH) r9r:rmrnr^ decoded_ix decoded_val decoded_shapelog_probabilitiess r'roro)s]R  * * #  ' AH=:{M+<  % %j+&3 5 67H JJr)znn.ctc_beam_search_decoderc tj|||||\}}}}t|||D cgc]\} } } tj| | | c} } } |fScc} } } w)aYPerforms beam search decoding on the logits given in input. **Note** Although in general greedy search is a special case of beam-search with `top_paths=1` and `beam_width=1`, `ctc_beam_search_decoder` differs from `ctc_greedy_decoder` in the treatment of blanks when computing the probability of a sequence: - `ctc_beam_search_decoder` treats blanks as sequence termination - `ctc_greedy_decoder` treats blanks as regular elements If `merge_repeated` is `True`, merge repeated classes in the output beams. This means that if consecutive entries in a beam are the same, only the first of these is emitted. That is, when the sequence is `A B B * B * B` (where '*' is the blank label), the return value is: * `A B` if `merge_repeated = True`. * `A B B B` if `merge_repeated = False`. Args: inputs: 3-D `float` `Tensor`, size `[max_time x batch_size x num_classes]`. The logits. sequence_length: 1-D `int32` vector containing sequence lengths, having size `[batch_size]`. beam_width: An int scalar >= 0 (beam search beam width). top_paths: An int scalar >= 0, <= beam_width (controls output size). merge_repeated: Boolean. Default: True. Returns: A tuple `(decoded, log_probabilities)` where decoded: A list of length top_paths, where `decoded[j]` is a `SparseTensor` containing the decoded outputs: `decoded[j].indices`: Indices matrix `(total_decoded_outputs[j] x 2)` The rows store: [batch, time]. `decoded[j].values`: Values vector, size `(total_decoded_outputs[j])`. The vector stores the decoded classes for beam j. `decoded[j].dense_shape`: Shape vector, size `(2)`. The shape values are: `[batch_size, max_decoded_length[j]]`. log_probability: A `float` matrix `(batch_size x top_paths)` containing sequence log-probabilities. ) beam_width top_pathsrm)rctc_beam_search_decoderzipr rH) r9r:rurvrm decoded_ixs decoded_valsdecoded_shapesrsixvalshapes r'rwrw|sj))  ' )?+|^->"+|^L   2sE  S%0   s"Aznn.ctc_beam_search_decoder_v2c"t||||dS)aPerforms beam search decoding on the logits given in input. **Note** Although in general greedy search is a special case of beam-search with `top_paths=1` and `beam_width=1`, `ctc_beam_search_decoder` differs from `ctc_greedy_decoder` in the treatment of blanks when computing the probability of a sequence: - `ctc_beam_search_decoder` treats blanks as sequence termination - `ctc_greedy_decoder` treats blanks as regular elements Args: inputs: 3-D `float` `Tensor`, size `[max_time, batch_size, num_classes]`. The logits. sequence_length: 1-D `int32` vector containing sequence lengths, having size `[batch_size]`. beam_width: An int scalar >= 0 (beam search beam width). top_paths: An int scalar >= 0, <= beam_width (controls output size). Returns: A tuple `(decoded, log_probabilities)` where decoded: A list of length top_paths, where `decoded[j]` is a `SparseTensor` containing the decoded outputs: `decoded[j].indices`: Indices matrix `[total_decoded_outputs[j], 2]`; The rows store: `[batch, time]`. `decoded[j].values`: Values vector, size `[total_decoded_outputs[j]]`. The vector stores the decoded classes for beam `j`. `decoded[j].dense_shape`: Shape vector, size `(2)`. The shape values are: `[batch_size, max_decoded_length[j]]`. log_probability: A `float` matrix `[batch_size, top_paths]` containing sequence log-probabilities. F)r:rurvrm)rw)r9r:rurvs r'ctc_beam_search_decoder_v2rs!X ! %  r)CTCGreedyDecoderCTCBeamSearchDecoderctjd5tj|d}t|d}t|d}|dz}d|z}t j |}||z}ddgg}t j|dd|ddgd}t j||gd} tj||| gd} tjt| dg} tj| | ||g } | tj|z } tj|dd} t j| |dd|ddgd} tjtj | d|ddg} tj t j |dgd z} | tj | dz } t j"|ddddf|ddddf}d t j$|t&j(z } |||g}tj| | |}tj | d|zcdddS#1swYyxYw) aComputes CTC alignment model transition matrix. Args: label_seq: tensor of shape [batch_size, max_seq_length] Returns: tensor of shape [batch_size, states, states] with a state transition matrix computed for each sequence of the batch. ctc_state_trans label_seqrBrrErFN)r~)rErr?)r name_scoperM_get_dimrranger stackr concatones scatter_ndreye zeros_liketile expand_dimsequalrRrrS)r batch_size num_labelsnum_label_states num_states label_states blank_statesstart_to_labelblank_to_labellabel_to_blankrUrVtrans batch_idxrepeats batched_shapelabel_to_labels r'_ctc_state_transrsL ~~'(+<%%ikBI)Q'J)Q'J!A~%%J>>"23L"22L!fXN%** ab <,-q2N%**L,+GKNO "G ^^Xgq12 3F   J7 9E Z^^J ''E$$\!"%56I## L$l1R&891>Gnngq)J1+=?G%%hnnZ&@!DyPI y$$Y22GnnYq#2#v. !QR%0@AG 8==&..9 9FZ8M))'6=IN   *^ ;W+<+<+t|d}|dz}d}||z}tjtjtjdtj dztj }tjtj|gtj|d|d}tj||d}tj|d|g} | |z} d | z |z} tj| ||g} |tj| fS) aComputes CTC alignment initial and final state log probabilities. Create the initial/final state values directly as log values to avoid having to take a float64 log on tpu (which does not exist). Args: seq_lengths: int tensor of shape [batch_size], seq lengths in the batch. max_seq_length: int, max sequence length possible. Returns: initial_state_log_probs, final_state_log_probs rrErFg @,1rO)rUdepthon_value off_valueaxis)rrr)rrrRlogrfloat64rSr one_hotzerosint32rreshaperN) seq_lengthsmax_seq_lengthrrnum_duration_statesrlog_0initial_state_log_probslabel_final_state_maskduration_final_state_maskfinal_state_maskfinal_state_log_probss r'ctc_state_log_probsr/s Q'*#a'"%55* --ll8==FNN3f<=v~~ O%&--oozl&,,?  %,,)3'nnAz*,.1GG!11U:#++,A-7,DF !)"5"56K"L LLr)ct|d}|ddddddf}tj|dd|dzg}tj||}tj|d}tj|d}t j ||zd}tj||gd}tj|ddgddgddggt jd S) z,Project ilabel log probs to state log probs.rEN)rrrrFr)constant_values) rr rrrr reduce_sumrpadr)r8rilabel_log_probsrblankrstate_log_probss r'_ilabel_to_staterWsfa( 1a!8 $% ..A'7!'; < =%   fJ 7'  ! !' 2'**+;!D''(87(BK/$$ou%=AF/ AAA/ll3' ))r)ct|ddz}|ddddd|f}|dddd|df}tj|dz |dz dtjd}tj |d}tj |d}tj ||zd}tj |dd }tj||gd S) z(Sum state log probs to ilabel log probs.rENr)rrrrrrrFTrkeepdimsr)rr rrrrreduce_logsumexpr) r8rstatesrrrr label_olabels blank_olabelss r'_state_to_olabelrgsfa(1,1a 0001,1.//0,    qj !^ S!  #'  ! !' 2'&&|!<,++L7,BK-++Lq4P-   =-8r BBr)c :t|ddz}|ddddd|f}|dddd|df}|\}}t||} t|d} t|d} |dz } tj| gd} tj| | | z| g} t j | |j|z}|tj|dz}tj|ddg}tj|| | |z| g }tj|| || g}tj| tj}tj||| |z| g }tj|| || g}tj||tjtj|t j d }tj|gd }|ddddddf}t j"|d d }tj$||gdS)zCSum state log probs to ilabel log probs using unique label indices.rENr)rErFrpermrrrrUupdatesr~r)rFrrErFTr)r _sum_statesr rNrrrrOrr ones_likerboolwherefillr~rrr)r8rruniquerrrunique_y unique_idx mul_reduce num_framesrrbatch_state_major batch_offsetrUscattermaskrrs r'_state_to_olabel_uniquerzsfa(1,1a 0001,1.//0,(J:|4*"*"*!#*))*9E''(9)3j)@*(MO (..AJN, y,,\C C'   gAw /'   * $j 1 3'   g J 'K L'   .fkk B$    * $j 1 3$   4*j*!E F$ OO GnnY__W-x||C/@A C'%%gy9-1ab)-++Lq4P-   =-8r BBr)cbt|d}t|d}tj|}t|||}t |} t ||\} } t tj| | | ||\} } |rt||| |}n t||| }tj|tj|z }t|d}tj||tj}tj |ddg}tj"|d}||z}| }||fS)aComputes the CTC loss and gradients. Most users will want fwd_bwd.ctc_loss This function returns the computed gradient, it does not have a gradient of its own defined. Args: logits: tensor of shape [frames, batch_size, num_labels] labels: tensor of shape [batch_size, max_label_seq_length] label_length: tensor of shape [batch_size] Length of reference label sequence in labels. logit_length: tensor of shape [batch_size] Length of input sequence in logits. unique: (optional) unique label indices as computed by unique(labels) If supplied, enables an implementation that is faster and more memory efficient on TPU. Returns: loss: tensor of shape [batch_size] gradient: tensor of shape [frames, batch_size, num_labels] rFrE)state_trans_log_probsrrobserved_log_probsr:rrr)rr log_softmaxrrr_forward_backward_logrrrrexpr sequence_maskrrSrNr)r?r8 label_length logit_lengthrrmax_label_seq_lengthrrstate_trans_probsrrfwd_bwd_log_probslog_likelihoodolabel_log_probsgradmax_logit_length logit_maskrYs r'ctc_loss_and_gradrs@0"*!&!,''/$VZ9IJ/&v.3F(4*00&;$LL):;51(" '$#^ .vz/@&J( r6 r rr rHrUrrV dense_shaper7r8r?rlogits_time_majorrn part_before part_after part_blanks r'_ctc_loss_op_standardrsq!\k\)*+aK!O,,-*aK a778*   [*jA J&  % % nnoofmmk16==mma')*0*<*< >&   ""  r)c~|ddddd|f}|dddd|dzdf}|dddd||dzf}tj|||gd}tj|jtj |j |k|j dz|j |j}t||||dS)NrErFrTrrrs r'_ctc_loss_op_cudnnrsq!\k\)*+aK!O,,-*aK a778*   ZjA J&  % % nnoofmmk16==13Dmm%&,&8&8 :&   ""  r)cv|jdj|jdjgS)NrFr)r9 get_shape)r_s r'_ctc_loss_shapers/ ))A, "BIIaL$:$:$< ==r)znn.ctc_loss_v2c 8t|tjr| td|dkr|t |dz }|t |ddz k7rt j |ddddd|f|dddd|dzdf|dddd||dzfgd}tj|jt j|j|k|j|jdz |j}t||||S|d}t||||||||S) aComputes CTC (Connectionist Temporal Classification) loss. This op implements the CTC loss as presented in (Graves et al., 2006). Notes: - Same as the "Classic CTC" in TensorFlow 1.x's tf.compat.v1.nn.ctc_loss setting of preprocess_collapse_repeated=False, ctc_merge_repeated=True - Labels may be supplied as either a dense, zero-padded tensor with a vector of label sequence lengths OR as a SparseTensor. - On TPU and GPU: Only dense padded labels are supported. - On CPU: Caller may use SparseTensor or dense padded labels but calling with a SparseTensor will be significantly faster. - Default blank label is 0 rather num_classes - 1, unless overridden by blank_index. Args: labels: tensor of shape [batch_size, max_label_seq_length] or SparseTensor logits: tensor of shape [frames, batch_size, num_labels], if logits_time_major == False, shape is [batch_size, frames, num_labels]. label_length: tensor of shape [batch_size], None if labels is SparseTensor Length of reference label sequence in labels. logit_length: tensor of shape [batch_size] Length of input sequence in logits. logits_time_major: (optional) If True (default), logits is shaped [time, batch, logits]. If False, shape is [batch, time, logits] unique: (optional) Unique label indices as computed by ctc_unique_labels(labels). If supplied, enable a faster, memory efficient implementation on TPU. blank_index: (optional) Set the class index to use for the blank label. Negative values will start from num_classes, ie, -1 will reproduce the ctc_loss behavior of using num_classes - 1 for the blank symbol. There is some memory/performance overhead to switching from the default of 0 as an additional shifted copy of the logits may be created. name: A name for this `Op`. Defaults to "ctc_loss_dense". Returns: loss: tensor of shape [batch_size], negative log probabilities. References: Connectionist Temporal Classification - Labeling Unsegmented Sequence Data with Recurrent Neural Networks: [Graves et al., 2006](https://dl.acm.org/citation.cfm?id=1143891) ([pdf](http://www.cs.toronto.edu/~graves/icml_2006.pdf)) NzFArgument `blank_index` must be provided when labels is a SparseTensor.rrFrEr)r8r9r:r>r8r?rrrrrnrC) rGr rH ValueErrorrr rrUrrVrr@ctc_loss_densers r'rTrTsOn 223   QXfa((khvq)A-- A| |# $ A{Q'' ( A{;?22 3! &' (f )) .. //&--+5v}} --!+ -.4.@.@Bf $$  && K   )   r)c t|tjr(| td|dkr|t |dz }t j |d}|||||d}tjrNt} | tk(xs| duxrtjdkD} | r td i|} | Std i|} | Sdttj z} t#| t$t} t#| tt}| d i|} |j&d i|}|j)|j+| S|d}t-|||||||| S) aComputes CTC (Connectionist Temporal Classification) loss. This op implements the CTC loss as presented in [Graves et al., 2006](https://www.cs.toronto.edu/~graves/icml_2006.pdf) Connectionist temporal classification (CTC) is a type of neural network output and associated scoring function, for training recurrent neural networks (RNNs) such as LSTM networks to tackle sequence problems where the timing is variable. It can be used for tasks like on-line handwriting recognition or recognizing phones in speech audio. CTC refers to the outputs and scoring, and is independent of the underlying neural network structure. Notes: - This class performs the softmax operation for you, so `logits` should be e.g. linear projections of outputs by an LSTM. - Outputs true repeated classes with blanks in between, and can also output repeated classes with no blanks in between that need to be collapsed by the decoder. - `labels` may be supplied as either a dense, zero-padded `Tensor` with a vector of label sequence lengths OR as a `SparseTensor`. - On TPU: Only dense padded `labels` are supported. - On CPU and GPU: Caller may use `SparseTensor` or dense padded `labels` but calling with a `SparseTensor` will be significantly faster. - Default blank label is `0` instead of `num_labels - 1` (where `num_labels` is the innermost dimension size of `logits`), unless overridden by `blank_index`. >>> tf.random.set_seed(50) >>> batch_size = 8 >>> num_labels = 6 >>> max_label_length = 5 >>> num_frames = 12 >>> labels = tf.random.uniform([batch_size, max_label_length], ... minval=1, maxval=num_labels, dtype=tf.int64) >>> logits = tf.random.uniform([num_frames, batch_size, num_labels]) >>> label_length = tf.random.uniform([batch_size], minval=2, ... maxval=max_label_length, dtype=tf.int64) >>> label_mask = tf.sequence_mask(label_length, maxlen=max_label_length, ... dtype=label_length.dtype) >>> labels *= label_mask >>> logit_length = [num_frames] * batch_size >>> with tf.GradientTape() as t: ... t.watch(logits) ... ref_loss = tf.nn.ctc_loss( ... labels=labels, ... logits=logits, ... label_length=label_length, ... logit_length=logit_length, ... blank_index=0) >>> ref_grad = t.gradient(ref_loss, logits) Args: labels: `Tensor` of shape `[batch_size, max_label_seq_length]` or `SparseTensor`. logits: `Tensor` of shape `[frames, batch_size, num_labels]`. If `logits_time_major == False`, shape is `[batch_size, frames, num_labels]`. label_length: `Tensor` of shape `[batch_size]`. None, if `labels` is a `SparseTensor`. Length of reference label sequence in `labels`. logit_length: `Tensor` of shape `[batch_size]`. Length of input sequence in `logits`. logits_time_major: (optional) If True (default), `logits` is shaped [frames, batch_size, num_labels]. If False, shape is `[batch_size, frames, num_labels]`. unique: (optional) Unique label indices as computed by `ctc_unique_labels(labels)`. If supplied, enable a faster, memory efficient implementation on TPU. blank_index: (optional) Set the class index to use for the blank label. Negative values will start from `num_labels`, ie, `-1` will reproduce the ctc_loss behavior of using `num_labels - 1` for the blank symbol. There is some memory/performance overhead to switching from the default of 0 as an additional shifted copy of `logits` may be created. name: A name for this `Op`. Defaults to "ctc_loss_dense". Returns: loss: A 1-D `float Tensor` of shape `[batch_size]`, containing negative log probabilities. Raises: ValueError: Argument `blank_index` must be provided when `labels` is a `SparseTensor`. References: Connectionist Temporal Classification - Labeling Unsegmented Sequence Data with Recurrent Neural Networks: [Graves et al., 2006](https://dl.acm.org/citation.cfm?id=1143891) ([pdf](http://www.cs.toronto.edu/~graves/icml_2006.pdf)) https://en.wikipedia.org/wiki/Connectionist_temporal_classification NzJArgument `blank_index` must be provided when `labels` is a `SparseTensor`.rrFr?rB)r8r?rrrn ctc_loss_r)rGr rHrrr rMrexecuting_eagerlyr(_GPU_DEVICE_NAMEnum_gpusrrstruuiduuid4r3_CPU_DEVICE_NAMEget_concrete_function add_to_graphadd_gradient_functions_to_graphr)r8r?rrrrrnrCparamsr% can_use_gpuresapi_namectc_loss_op_standardctc_loss_op_cudnn concrete_funcs r' ctc_loss_v3rssH 223   QXfa((k  " "6 9F$." F  ",.k * * < 4  :G$4$4$6$:  *6* J$-f- Js4::<00h4X?O5JL1(.compute_ctc_loss..gradsD!!)Z86!9DE #d)c$i/00 r)rr ) set_shaper~dictr) logits_tlabels_tlabel_length_tlogit_length_tunique_tkwargsrr"r!rr8rr?s @r'compute_ctc_lossz(ctc_loss_dense..compute_ctc_lossws&&|112|112%% 'f #x *6*f AY_r))r rrMrOrrPrQrrRrSr rNrrr reduce_maxrrextendr)r8r?rrrrrnrCrWrrlabel_mask_lenmax_label_length label_maskr+rYr!s```` @r'rrs[B ~~d,v|\BDA  " "6 9F  " "6 9F((NKL((NKLJfnnfoo66}}VV^^4f ""6 :fa qx**  A{;?22 3 A| |# $ A{Q'' (! &' (f v 3VaZHf FL, 7D #h  ??8k#98a<#+-!,,Za@1D#Ha0,,^=MN ??:x#,#7#7#AC kk8Z()$$%, T "Dfnnfoo66 ]]4 ,d CAAAs II11I:znn.collapse_repeatedc tj|d||g5tj|d}tj|d}tjtj |ddddft jtj|ddddf|ddddfgd}t|d}tj|| }tj||}tjtj|t jd}tj |}tj|| }tj"|dg} tj"|dg} tj"|dg} tj$t| d } tj&tj(tj*| | dtj*| | tj,|  } t|d }||g}tj"| |tj||j.fcdddS#1swYyxYw) alMerge repeated labels into single labels. Args: labels: Tensor of shape [batch, max value in seq_length] seq_length: Tensor of shape [batch], sequence length of each batch element. name: A name for this `Op`. Defaults to "collapse_repeated_labels". Returns: A tuple `(collapsed_labels, new_seq_length)` where collapsed_labels: Tensor of shape [batch, max_seq_length] with repeated labels collapsed and padded to max_seq_length, eg: `[[A, A, B, B, A], [A, B, C, D, E]] => [[A, B, A, 0, 0], [A, B, C, D, E]]` new_seq_length: int tensor of shape [batch] with new sequence lengths. collapse_repeated_labelsr8rB seq_lengthNrErrmaxlenrr)r rrMr rrrrr not_equalrr logical_andrrRrr,rrrr boolean_maskr~rO)r8r3rCr0r5seq_mask new_seq_len new_maxlenidx_mask flat_labelsflat_label_mask flat_idx_maskidxflatr new_shapes r'collapse_repeatedrCs( ~~d68LM):  " "6 9F&&z EJ!!F1bqb5M6;;76!QR%=&CRC.9#() *Jfa F&&z&AH%%j(;J%% j&,,/a9K$$[1J&&{:FH##FRD1K'' RD9O%%h5M ..-3 4C   %%  " "3 6Q@&&{ODoom,  .D&!$JZ(I   dI . MM+z'7'7 8 :Q):):):s II,,I5c tj|dg}tjtj|t j d}tj|tj|d}tj|dg}tjtj||d}tj||}tj|tj|t jtj|t j }tj|tj|} tj |} tj| j"| j$tj| j&dt j tj| t j gS)a"Convert dense labels with sequence lengths to sparse tensor. Args: dense: tensor of shape [batch, max_length] length: int tensor of shape [batch] The length of each sequence in dense. Returns: tf.sparse.SparseTensor with values only for the valid elements of sequences. r)out_typerrEr4)rUrVr)r rrrr~rint64rrr8r rHrRrrsparse_reshaper,rUrVr) denselength flat_values flat_indicesr flat_maskrUrVsparsereshaped max_lengths r'dense_labels_to_sparserPsa!!%".+ookFLL9!<>,   0Fq0I J$rd+)  ! !\95q :'  ! !+y 9&  % % ]]66<< 0//+ E G& & &vyu/E F(""6**  # # __ --,,Q/ > -- FLL 1  r)znn.ctc_unique_labelsctj|d|g5tj|d}d}tj||tj tj gcdddS#1swYyxYw)aGet unique labels and indices for batched labels for `tf.nn.ctc_loss`. For use with `tf.nn.ctc_loss` optional argument `unique`: This op can be used to preprocess labels in input pipeline to for better speed/memory use computing the ctc loss on TPU. Example: ctc_unique_labels([[3, 4, 4, 3]]) -> unique labels padded with 0: [[3, 4, 0, 0]] indices of original labels in unique: [0, 1, 1, 0] Args: labels: tensor of shape [batch_size, max_label_length] padded with 0. name: A name for this `Op`. Defaults to "ctc_unique_labels". Returns: tuple of - unique labels, tensor of shape `[batch_size, max_label_length]` - indices into unique labels, shape `[batch_size, max_label_length]` ctc_unique_labelsr8rBc ,tj|}tj|jdt |j dt |jdz gg}t j|tj}||j gSNr) r rryrr@rrRrrF)xurUs r'_uniquez"ctc_unique_labels.._uniquesk   1 a --q(155!"4xQ7G"GHI Ja --6<< (aZr)rN)r rrMrrrFr)r8rCrXs r'rRrRsf0 ~~d/&: N  " "6 9F ==&v||0L M N N Ns AA33A<c Ztjd5tj|d}t|d}t j |d}t j ||dtjdd}tj||zd cd d d S#1swYy xYw) aTake logsumexp for each unique state out of all label states. Args: idx: tensor of shape [batch, label_length] For each sequence, indices into a set of unique labels as computed by calling unique. states: tensor of shape [frames, batch, label_length] Log probabilities for each label state. Returns: tensor of shape [frames, batch_size, label_length], log probabilities summed for each unique label of the sequence. sum_statesr@rBrFrrrE)rrrrrN) r rrMrr rrrrr)r@rrrs r'rrs ~~l# @  % 0C&!$J  " "6 2F ,,s#  G  $ $Vg%5B ? @ @ @s BB!!B*cjjdk(rddg}nCjjdk(rgd}n%tddjjtj|t |d}fd}t |||d }fd } tj|g} t |d} tj|| tj} tj| ddg } t | || f| fd d \} }|dd| ddz}tj|dd }||z}|tjtj| dz }| ddddf|dz}||fS)aForward-backward algorithm computed in log domain. Args: state_trans_log_probs: tensor of shape [states, states] or if different transition matrix per batch [batch_size, states, states] initial_state_log_probs: tensor of shape [batch_size, states] final_state_log_probs: tensor of shape [batch_size, states] observed_log_probs: tensor of shape [frames, batch_size, states] sequence_length: tensor of shape [batch_size] Returns: forward backward log probabilities: tensor of shape [frames, batch, states] log_likelihood: tensor of shape [batch_size] Raises: ValueError: If state_trans_log_probs has unknown or incorrect rank. rFrErr)rrFrEzkRank of argument `state_trans_log_probs` must be known and equal to 2 or 3. Received state_trans_log_probs=z of rank ctj|d}|z }tj|d}||z }tj|dd}||z}|S)NrErrTr)r rrr)state_log_prob obs_log_prob log_prob_sumrs r'_forwardz'_forward_backward_log.._forwardWsc**>BN++N..~BGNl"N,,R$0Ll"N r)T) inclusivecT|\}}|\}}||z }tj|d}| z }tj|d}tj|dd}||z}|tj|dg|zz }tj|d}||z}| d|z zz }||fS)zBCalculate log probs and cumulative sum masked for sequence length.rErrTrr)r rrrsqueeze) accselemsr] cum_log_sumr^rr_ batched_maskoutbwd_state_trans_log_probsrs r' _backwardz(_forward_backward_log.._backwardds"&NKL$l"N**>BN//N..~BGN,,R$0Ll"N9$$\=DDK((A6L < 'C C,$6 77C  r)r)reverseraNrr)r~ndimsrr rNr_scanrrrrSrrrr)rrrrr:rrr`fwdrj zero_log_sumr5rbwdrfrfwd_bwd_log_probs_sumrris` ` @r'rr5s*  &&!+ q6D""((A- D  22G1HI%++112 4 55 (112GN*A.* "$;t M#&*., & *&  &&.. I$   TA /$$d+l+ #{ !"gAB'"33a$0,,x||I$9$9$Q$GHHq!Qw<+a.0. N **r)ctjDcgc]}tj|c}t j dd}fdtjDcgc]}tj|}}fd|Dcgc]}|j } }t|r$tjtjg| z} n&tjtjg| z| z} fd} fd} rt j dddz n$tjdtj} g}st j ddrdndz}|D]}t j|gt j |gd}tj||j d }r!tj || rdndzgg|g}|j#|| |g|z|z}t%|Dcgc]=\}}|j j&tjtj(fvr|?}}}t+j,r|}| |rU| |}| |r nIt/j0| | } t/j0| | } t3j4|| | | }|d d z}|Scc}wcc}wcc}wcc}}w) abRepeatedly applies callable `fn` to a sequence of elements. Implemented by functional_ops.While, tpu friendly, no gradient. This is similar to functional_ops.scan but significantly faster on tpu/gpu for the forward backward use case. Examples: scan(lambda a, e: a + e, [1.0, 2.0, 3.0], 1.0) => [2.0, 4.0, 7.0] Multiple accumulators: scan(lambda a, e: (a[0] + e, a[1] * e), [1.0, 2.0, 3.0], (0.0, 1.0)) Multiple inputs: scan(lambda a, e: a + (e[0] * e[1]), (elems1, elems2), 0.0) Args: fn: callable, fn(accumulators, element) return new accumulator values. The (possibly nested) sequence of accumulators is the same as `initial` and the return value must have the same structure. elems: A (possibly nested) tensor which will be unpacked along the first dimension. The resulting slices will be the second argument to fn. The first dimension of all nested input tensors must be the same. initial: A tensor or (possibly nested) sequence of tensors with initial values for the accumulators. reverse: (optional) True enables scan and output elems in reverse order. inclusive: (optional) True includes the initial accumulator values in the output. Length of output will be len(elem sequence) + 1. Not meaningful if final_only is True. final_only: (optional) When True, return only the final accumulated values, not the concatenation of accumulated values for each input. Returns: A (possibly nested) sequence of tensors with the results of applying fn to tensors unpacked from elems and previous accumulator values. rc2tj|SN) structure flat_sequencerpack_sequence_as)rVres r'z_scan..s..aPr)c2tj|Srtrw)rVinitials r'ryz_scan..s4((7!Lr)c~r|dk\S||kSrTr )i num_elemsr!rks r'condz_scan..conds 16/!i-/r)c |jg r|}n |d|d}} Dcgc]}tj||}}||}tj|} rg}nArs|dzn|} t |D cgc]\} } t j| | gg| g!}} } r|dz n|dz}||g|z|zScc}wcc} } w)z Loop body.NrE)r#r gatherrflattenrxrtensor_scatter_update)r}r~r!accumrheslices flat_accumnew_outupdate_irVrU final_only flat_elemsfnra num_accumspack pack_elemsrks r'bodyz_scan..bodysKKOe $d:;&75c.8 9iq!$ 9F 9 tE{Jv. /Ee$Jg#GQh#z*a  - -a8*s CgAa!eA y>G #j 00:s C $CrErT)rOinit)hostmemrF)rrr rMr r~rOrrrrconstantrremptyrtensor_scatter_addappend enumerate base_dtyperFrr rDefunrWhile)rrer{rkrarrVr~ flat_initial accum_dtypes loop_dtypesrrinit_ir^ num_outputs initial_accum out_shaperhloop_inr}r loop_resultsrrrrs`````` @@@@r'rmrmsL37,,u2EFQ%%a(F*oojm,Q/)P*48LL4IJq#''*J,J L$#/0a!''0,0< *<<.=K<<.= LK0 11. oojm$Q'#,,QfllC  ' //*Q-03Iq1MK% "" =)//-8 91>i   i}/B/B Nc .. 6'Qq123m_ nnSY ' )L 8'g&  Aq    fll; ; '    L  <(l   (8>>; ' -D '8>>; ' -D!''tWMLQzA~&# cSGK0j sK-8K2K7(AK<cztj|j|xstj||S)zBGet value of tensor shape[i] preferring static value if available.)r dimension_valuer~r )tensorr}s r'rrs6  % % ll1o  5#//&1!45r))NNFTFTN)NNFTFTNF)TN)drET)rrE)N)TNNN)TNrN)FFF)G__doc__rtensorflow.python.eagerrrtensorflow.python.frameworkrrrrr r r tensorflow.python.opsr r rrrrrrrrrrtensorflow.python.ops.nn_gradrtensorflow.python.utilrrr tensorflow.python.util.tf_exportrr.r/rr r(r3add_dispatch_supportr@r7rbRegisterGradientrgrkrorwrNotDifferentiablerrrrrrrrrrrTrrrCrPrRrrrmrr r)r'rs'> +03..0+54+110/--,(*(,7.+'6,0CO }o !*/ $/4xxx#'05&*5:""3lM$i  ,! ,k" ,# , "# '+#'NJ$NJb +,- (+&'+/ =.=@ '-L,MN +.)*/O/d(),-6   !  #' ["[| =R   #' W!W|&* BJ !" ;:#;:| D !" N#ND@6U+vod5r)