



import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
   import torch


_lowercase    	=		random.Random()



def 		lowerCAmelCase__     (       UpperCamelCase_					:							int			,							UpperCamelCase_					:							List[str]=1.0			,							UpperCamelCase_					:							Dict=None			,							UpperCamelCase_					:							str=None						)->	Dict:
    if rng is None:
        A__					=       global_rng

    A__					=       []
    for batch_idx in range(shape[0]						):
        values.append([]						)
        for _ in range(shape[1]						):
            values[-1].append(rng.random() * scale						)

    return values



@require_torch
class      _UpperCAmelCase      (							unittest.TestCase  ):




     def __init__(					self			,    a__			,    a__=7			,    a__=4_0_0			,    a__=2_0_0_0			,    a__=1			,    a__=0.0			,    a__=1_6_0_0_0			,    a__=True			,    a__=8_0			,    a__=1_6			,    a__=6_4			,    a__="hann_window"			,    a__=8_0			,    a__=7_6_0_0			,    a__=1e-10			,    a__=True			,    ):
         A__					=       parent
         A__					=       batch_size
         A__					=       min_seq_length
         A__					=       max_seq_length
         A__					=       (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
         A__					=       feature_size
         A__					=       padding_value
         A__					=       sampling_rate
         A__					=       do_normalize
         A__					=       num_mel_bins
         A__					=       hop_length
         A__					=       win_length
         A__					=       win_function
         A__					=       fmin
         A__					=       fmax
         A__					=       mel_floor
         A__					=       return_attention_mask




     def 		snake_case_		(					self):
         return {
             "feature_size": self.feature_size,
             "padding_value": self.padding_value,
             "sampling_rate": self.sampling_rate,
             "do_normalize": self.do_normalize,
             "num_mel_bins": self.num_mel_bins,
             "hop_length": self.hop_length,
             "win_length": self.win_length,
             "win_function": self.win_function,
             "fmin": self.fmin,
             "fmax": self.fmax,
             "mel_floor": self.mel_floor,
             "return_attention_mask": self.return_attention_mask,
         }




     def 		snake_case_		(					self			,    a__=False			,    a__=False):
         def _flatten(a__):
             return list(itertools.chain(*a__))

         if equal_length:
             A__					=       floats_list((self.batch_size, self.max_seq_length))
         else:
             # make sure that inputs increase in size
             A__					=       [
                 _flatten(floats_list((x, self.feature_size)))
                 for x in range(self.min_seq_length			,    self.max_seq_length			,    self.seq_length_diff)
             ]

         if numpify:
             A__					=       [np.asarray(a__) for x in speech_inputs]

         return speech_inputs




     def 		snake_case_		(					self			,    a__=False			,    a__=False):
         if equal_length:
             A__					=       [floats_list((self.max_seq_length, self.num_mel_bins)) for _ in range(self.batch_size)]
         else:
             # make sure that inputs increase in size
             A__					=       [
                 floats_list((x, self.num_mel_bins))
                 for x in range(self.min_seq_length			,    self.max_seq_length			,    self.seq_length_diff)
             ]

         if numpify:
             A__					=       [np.asarray(a__) for x in speech_inputs]

         return speech_inputs







@require_torch
class      _UpperCAmelCase      (							A__      ,   unittest.TestCase  ):
     UpperCamelCase__		     =					SpeechTaFeatureExtractor




     def 		snake_case_		(					self):
         A__					=       SpeechTaFeatureExtractionTester(self)




     def 		snake_case_		(					self			,    a__):
         self.assertTrue(np.all(np.mean(a__			,    axis=0) < 1e-3))
         self.assertTrue(np.all(np.abs(np.var(a__			,    axis=0) - 1) < 1e-3))




     def 		snake_case_		(					self):
         # Tests that all call wrap to encode_plus and batch_encode_plus
         A__					=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
         # create three inputs of length 800, 1000, and 1200
         A__					=       [floats_list((1, x))[0] for x in range(8_0_0			,    1_4_0_0			,    2_0_0)]
         A__					=       [np.asarray(a__) for speech_input in speech_inputs]

         # Test not batched input
         A__					=       feat_extract(speech_inputs[0]			,    return_tensors='''np''').input_values
         A__					=       feat_extract(np_speech_inputs[0]			,    return_tensors='''np''').input_values
         self.assertTrue(np.allclose(a__			,    a__			,    atol=1e-3))

         # Test batched
         A__					=       feat_extract(a__			,    return_tensors='''np''').input_values
         A__					=       feat_extract(a__			,    return_tensors='''np''').input_values
         for enc_seq_a, enc_seq_a in zip(a__			,    a__):
             self.assertTrue(np.allclose(a__			,    a__			,    atol=1e-3))




     def 		snake_case_		(					self):
         A__					=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
         A__					=       [floats_list((1, x))[0] for x in range(8_0_0			,    1_4_0_0			,    2_0_0)]

         A__					=       ['''longest''', '''max_length''', '''do_not_pad''']
         A__					=       [None, 1_6_0_0, None]
         for max_length, padding in zip(a__			,    a__):
             A__					=       feat_extract(a__			,    padding=a__			,    max_length=a__			,    return_tensors='''np''')
             A__					=       processed.input_values

             self._check_zero_mean_unit_variance(input_values[0][:8_0_0])
             self.assertTrue(input_values[0][8_0_0:].sum() < 1e-6)
             self._check_zero_mean_unit_variance(input_values[1][:1_0_0_0])
             self.assertTrue(input_values[0][1_0_0_0:].sum() < 1e-6)
             self._check_zero_mean_unit_variance(input_values[2][:1_2_0_0])




     def 		snake_case_		(					self):
         A__					=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
         A__					=       range(8_0_0			,    1_4_0_0			,    2_0_0)
         A__					=       [floats_list((1, x))[0] for x in lengths]

         A__					=       ['''longest''', '''max_length''', '''do_not_pad''']
         A__					=       [None, 1_6_0_0, None]

         for max_length, padding in zip(a__			,    a__):
             A__					=       feat_extract(a__			,    max_length=a__			,    padding=a__)
             A__					=       processed.input_values

             self._check_zero_mean_unit_variance(input_values[0][:8_0_0])
             self._check_zero_mean_unit_variance(input_values[1][:1_0_0_0])
             self._check_zero_mean_unit_variance(input_values[2][:1_2_0_0])




     def 		snake_case_		(					self):
         A__					=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
         A__					=       [floats_list((1, x))[0] for x in range(8_0_0			,    1_4_0_0			,    2_0_0)]
         A__					=       feat_extract(
             a__			,    truncation=a__			,    max_length=1_0_0_0			,    padding='''max_length'''			,    return_tensors='''np''')
         A__					=       processed.input_values

         self._check_zero_mean_unit_variance(input_values[0, :8_0_0])
         self._check_zero_mean_unit_variance(input_values[1])
         self._check_zero_mean_unit_variance(input_values[2])




     def 		snake_case_		(					self):
         A__					=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
         A__					=       [floats_list((1, x))[0] for x in range(8_0_0			,    1_4_0_0			,    2_0_0)]
         A__					=       feat_extract(
             a__			,    truncation=a__			,    max_length=1_0_0_0			,    padding='''longest'''			,    return_tensors='''np''')
         A__					=       processed.input_values

         self._check_zero_mean_unit_variance(input_values[0, :8_0_0])
         self._check_zero_mean_unit_variance(input_values[1, :1_0_0_0])
         self._check_zero_mean_unit_variance(input_values[2])

         # make sure that if max_length < longest -> then pad to max_length
         self.assertTrue(input_values.shape == (3, 1_0_0_0))

         A__					=       [floats_list((1, x))[0] for x in range(8_0_0			,    1_4_0_0			,    2_0_0)]
         A__					=       feat_extract(
             a__			,    truncation=a__			,    max_length=2_0_0_0			,    padding='''longest'''			,    return_tensors='''np''')
         A__					=       processed.input_values

         self._check_zero_mean_unit_variance(input_values[0, :8_0_0])
         self._check_zero_mean_unit_variance(input_values[1, :1_0_0_0])
         self._check_zero_mean_unit_variance(input_values[2])

         # make sure that if max_length > longest -> then pad to longest
         self.assertTrue(input_values.shape == (3, 1_2_0_0))




     def 		snake_case_		(					self):
         A__					=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
         A__					=       np.random.rand(1_0_0).astype(np.floataa)
         A__					=       np_speech_inputs.tolist()

         for inputs in [py_speech_inputs, np_speech_inputs]:
             A__					=       feature_extractor.pad([{'''input_values''': inputs}]			,    return_tensors='''np''')
             self.assertTrue(np_processed.input_values.dtype == np.floataa)
             A__					=       feature_extractor.pad([{'''input_values''': inputs}]			,    return_tensors='''pt''')
             self.assertTrue(pt_processed.input_values.dtype == torch.floataa)




     def 		snake_case_		(					self):
         # Tests that all call wrap to encode_plus and batch_encode_plus
         A__					=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
         # create three inputs of length 800, 1000, and 1200
         A__					=       [floats_list((1, x))[0] for x in range(8_0_0			,    1_4_0_0			,    2_0_0)]
         A__					=       [np.asarray(a__) for speech_input in speech_inputs]

         # Test feature size
         A__					=       feature_extractor(audio_target=a__			,    padding=a__			,    return_tensors='''np''').input_values
         self.assertTrue(input_values.ndim == 3)
         self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins)

         # Test not batched input
         A__					=       feature_extractor(speech_inputs[0]			,    return_tensors='''np''').input_values
         A__					=       feature_extractor(np_speech_inputs[0]			,    return_tensors='''np''').input_values
         self.assertTrue(np.allclose(a__			,    a__			,    atol=1e-3))

         # Test batched
         A__					=       feature_extractor(a__			,    return_tensors='''np''').input_values
         A__					=       feature_extractor(a__			,    return_tensors='''np''').input_values
         for enc_seq_a, enc_seq_a in zip(a__			,    a__):
             self.assertTrue(np.allclose(a__			,    a__			,    atol=1e-3))

         # Test 2-D numpy arrays are batched.
         A__					=       [floats_list((1, x))[0] for x in (8_0_0, 8_0_0, 8_0_0)]
         A__					=       np.asarray(a__)
         A__					=       feature_extractor(a__			,    return_tensors='''np''').input_values
         A__					=       feature_extractor(a__			,    return_tensors='''np''').input_values
         for enc_seq_a, enc_seq_a in zip(a__			,    a__):
             self.assertTrue(np.allclose(a__			,    a__			,    atol=1e-3))




     def 		snake_case_		(					self):
         A__					=       self.feat_extract_tester.prepare_inputs_for_target()
         A__					=       self.feature_extraction_class(**self.feat_extract_dict)
         A__					=       feat_extract.model_input_names[0]

         A__					=       BatchFeature({input_name: speech_inputs})

         self.assertTrue(all(len(a__) == len(a__) for x, y in zip(a__			,    processed_features[input_name])))

         A__					=       self.feat_extract_tester.prepare_inputs_for_target(equal_length=a__)
         A__					=       BatchFeature({input_name: speech_inputs}			,    tensor_type='''np''')

         A__					=       processed_features[input_name]

         if len(batch_features_input.shape) < 3:
             A__					=       batch_features_input[:, :, None]

         self.assertTrue(
             batch_features_input.shape
             == (self.feat_extract_tester.batch_size, len(speech_inputs[0]), self.feat_extract_tester.num_mel_bins))




     @require_torch
     def 		snake_case_		(					self):
         A__					=       self.feat_extract_tester.prepare_inputs_for_target(equal_length=a__)
         A__					=       self.feature_extraction_class(**self.feat_extract_dict)
         A__					=       feat_extract.model_input_names[0]

         A__					=       BatchFeature({input_name: speech_inputs}			,    tensor_type='''pt''')

         A__					=       processed_features[input_name]

         if len(batch_features_input.shape) < 3:
             A__					=       batch_features_input[:, :, None]

         self.assertTrue(
             batch_features_input.shape
             == (self.feat_extract_tester.batch_size, len(speech_inputs[0]), self.feat_extract_tester.num_mel_bins))




     @require_torch
     def 		snake_case_		(					self):
         A__					=       self.feature_extraction_class(**self.feat_extract_dict)
         A__					=       self.feat_extract_tester.prepare_inputs_for_target()
         A__					=       feat_extract.model_input_names[0]

         A__					=       BatchFeature({input_name: speech_inputs})

         A__					=       feat_extract.num_mel_bins  # hack!

         A__					=       feat_extract.pad(a__			,    padding='''longest'''			,    return_tensors='''np''')[input_name]
         A__					=       feat_extract.pad(a__			,    padding='''longest'''			,    return_tensors='''pt''')[input_name]

         self.assertTrue(abs(input_np.astype(np.floataa).sum() - input_pt.numpy().astype(np.floataa).sum()) < 1e-2)




     def 		snake_case_		(					self):
         A__					=       self.feat_extract_dict
         A__					=       True
         A__					=       self.feature_extraction_class(**a__)
         A__					=       self.feat_extract_tester.prepare_inputs_for_target()
         A__					=       [len(a__) for x in speech_inputs]
         A__					=       feat_extract.model_input_names[0]

         A__					=       BatchFeature({input_name: speech_inputs})

         A__					=       feat_extract.num_mel_bins  # hack!

         A__					=       feat_extract.pad(a__			,    padding='''longest'''			,    return_tensors='''np''')
         self.assertIn('''attention_mask'''			,    a__)
         self.assertListEqual(list(processed.attention_mask.shape)			,    list(processed[input_name].shape[:2]))
         self.assertListEqual(processed.attention_mask.sum(-1).tolist()			,    a__)




     def 		snake_case_		(					self):
         A__					=       self.feat_extract_dict
         A__					=       True
         A__					=       self.feature_extraction_class(**a__)
         A__					=       self.feat_extract_tester.prepare_inputs_for_target()
         A__					=       [len(a__) for x in speech_inputs]
         A__					=       feat_extract.model_input_names[0]

         A__					=       BatchFeature({input_name: speech_inputs})
         A__					=       min(a__)

         A__					=       feat_extract.num_mel_bins  # hack!

         A__					=       feat_extract.pad(
             a__			,    padding='''max_length'''			,    max_length=a__			,    truncation=a__			,    return_tensors='''np''')
         self.assertIn('''attention_mask'''			,    a__)
         self.assertListEqual(
             list(processed_pad.attention_mask.shape)			,    [processed_pad[input_name].shape[0], max_length])
         self.assertListEqual(
             processed_pad.attention_mask[:, :max_length].sum(-1).tolist()			,    [max_length for x in speech_inputs])




     def 		snake_case_		(					self			,    a__):
         from datasets import load_dataset

         A__					=       load_dataset('''hf-internal-testing/librispeech_asr_dummy'''			,    '''clean'''			,    split='''validation''')
         # automatic decoding with librispeech
         A__					=       ds.sort('''id''').select(range(a__))[:num_samples]['''audio''']

         return [x["array"] for x in speech_samples]




     def 		snake_case_		(					self):
         # fmt: off
         A__					=       torch.tensor(
             [2.3_804e-03, 2.0_752e-03, 1.9_836e-03, 2.1_057e-03, 1.6_174e-03,
              3.0_518e-04, 9.1_553e-05, 3.3_569e-04, 9.7_656e-04, 1.8_311e-03,
              2.0_142e-03, 2.1_057e-03, 1.7_395e-03, 4.5_776e-04, -3.9_673e-04,
              4.5_776e-04, 1.0_071e-03, 9.1_553e-05, 4.8_828e-04, 1.1_597e-03,
              7.3_242e-04, 9.4_604e-04, 1.8_005e-03, 1.8_311e-03, 8.8_501e-04,
              4.2_725e-04, 4.8_828e-04, 7.3_242e-04, 1.0_986e-03, 2.1_057e-03])
         # fmt: on

         A__					=       self._load_datasamples(1)
         A__					=       SpeechTaFeatureExtractor()
         A__					=       feature_extractor(a__			,    return_tensors='''pt''').input_values
         self.assertEquals(input_values.shape			,    (1, 9_3_6_8_0))
         self.assertTrue(torch.allclose(input_values[0, :3_0]			,    a__			,    atol=1e-6))




     def 		snake_case_		(					self):
         # fmt: off
         A__					=       torch.tensor(
             [-2.6_8_7_0, -3.0_1_0_4, -3.1_3_5_6, -3.5_3_5_2, -3.0_0_4_4, -3.0_3_5_3, -3.4_7_1_9, -3.6_7_7_7,
              -3.1_5_2_0, -2.9_4_3_5, -2.6_5_5_3, -2.8_7_9_5, -2.9_9_4_4, -2.5_9_2_1, -3.0_2_7_9, -3.0_3_8_6,
              -3.0_8_6_4, -3.1_2_9_1, -3.2_3_5_3, -2.7_4_4_4, -2.6_8_3_1, -2.7_2_8_7, -3.1_7_6_1, -3.1_5_7_1,
              -3.2_7_2_6, -3.0_5_8_2, -3.1_0_0_7, -3.4_5_3_3, -3.4_6_9_5, -3.0_9_9_8])
         # fmt: on

         A__					=       self._load_datasamples(1)
         A__					=       SpeechTaFeatureExtractor()
         A__					=       feature_extractor(audio_target=a__			,    return_tensors='''pt''').input_values
         self.assertEquals(input_values.shape			,    (1, 3_6_6, 8_0))
         self.assertTrue(torch.allclose(input_values[0, 0, :3_0]			,    a__			,    atol=1e-4))





from typing import Optional

import numpy as np
import torch
from torch import nn
from transformers import GPTaConfig, GPTaLMHeadModel
from transformers.modeling_utils import ModuleUtilsMixin

from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin



class      _UpperCAmelCase      (							A__      ,   A__      ,   A__  ):
     UpperCamelCase__		     =					[r'''h\.\d+\.attn\.bias''', r'''h\.\d+\.attn\.masked_bias''']




     @register_to_config
     def __init__(					self			,    a__			,    a__			,    a__ = None			,    a__ = 5_0_2_5_7			,    a__ = 1_0_2_4			,    a__ = 7_6_8			,    a__ = 1_2			,    a__ = 1_2			,    a__ = None			,    a__ = "gelu_new"			,    a__ = 0.1			,    a__ = 0.1			,    a__ = 0.1			,    a__ = 1e-5			,    a__ = 0.0_2			,    a__ = True			,    a__ = True			,    a__ = False			,    a__ = False			,    ):
         super().__init__()

         A__					=       prefix_length

         if prefix_inner_dim != n_embd and prefix_hidden_dim is None:
             raise ValueError(
                 F"`prefix_hidden_dim` cannot be `None` when `prefix_inner_dim`: {prefix_hidden_dim} and"
                 F" `n_embd`: {n_embd} are not equal.")

         A__					=       prefix_inner_dim
         A__					=       prefix_hidden_dim

         A__					=       (
             nn.Linear(self.prefix_inner_dim			,    self.prefix_hidden_dim)
             if self.prefix_hidden_dim is not None
             else nn.Identity()
         )
         A__					=       (
             nn.Linear(self.prefix_hidden_dim			,    a__) if self.prefix_hidden_dim is not None else nn.Identity()
         )

         A__					=       GPTaConfig(
             vocab_size=a__			,    n_positions=a__			,    n_embd=a__			,    n_layer=a__			,    n_head=a__			,    n_inner=a__			,    activation_function=a__			,    resid_pdrop=a__			,    embd_pdrop=a__			,    attn_pdrop=a__			,    layer_norm_epsilon=a__			,    initializer_range=a__			,    scale_attn_weights=a__			,    use_cache=a__			,    scale_attn_by_inverse_layer_idx=a__			,    reorder_and_upcast_attn=a__			,    )
         A__					=       GPTaLMHeadModel(a__)




     def 		snake_case_		(					self			,    a__			,    a__			,    a__ = None			,    a__ = None			,    ):
         A__					=       self.transformer.transformer.wte(a__)
         A__					=       self.encode_prefix(a__)
         A__					=       self.decode_prefix(a__)
         A__					=       torch.cat((prefix_embeds, embedding_text)			,    dim=1)

         if labels is not None:
             A__					=       self.get_dummy_token(input_ids.shape[0]			,    input_ids.device)
             A__					=       torch.cat((dummy_token, input_ids)			,    dim=1)
         A__					=       self.transformer(inputs_embeds=a__			,    labels=a__			,    attention_mask=a__)
         if self.prefix_hidden_dim is not None:
             return out, hidden
         else:
             return out




     def 		snake_case_		(					self			,    a__			,    a__):
         return torch.zeros(a__			,    self.prefix_length			,    dtype=torch.intaa			,    device=a__)




     def 		snake_case_		(					self			,    a__):
         return self.encode_prefix(a__)




     @torch.no_grad()
     def 		snake_case_		(					self			,    a__			,    a__			,    a__):
         A__					=       torch.split(a__			,    1			,    dim=0)
         A__					=       []
         A__					=       []
         for feature in features:
             A__					=       self.decode_prefix(feature.to(a__))  # back to the clip feature
             # Only support beam search for now
             A__			,						A__					=       self.generate_beam(
                 input_embeds=a__			,    device=a__			,    eos_token_id=a__)
             generated_tokens.append(output_tokens[0])
             generated_seq_lengths.append(seq_lengths[0])
         A__					=       torch.stack(a__)
         A__					=       torch.stack(a__)
         return generated_tokens, generated_seq_lengths




     @torch.no_grad()
     def 		snake_case_		(					self			,    a__=None			,    a__=None			,    a__=None			,    a__ = 5			,    a__ = 6_7			,    a__ = 1.0			,    a__ = None			,    ):
         A__					=       eos_token_id
         A__					=       None
         A__					=       None
         A__					=       torch.ones(a__			,    device=a__			,    dtype=torch.int)
         A__					=       torch.zeros(a__			,    device=a__			,    dtype=torch.bool)

         if input_embeds is not None:
             A__					=       input_embeds
         else:
             A__					=       self.transformer.transformer.wte(a__)

         for i in range(a__):
             A__					=       self.transformer(inputs_embeds=a__)
             A__					=       outputs.logits
             A__					=       logits[:, -1, :] / (temperature if temperature > 0 else 1.0)
             A__					=       logits.softmax(-1).log()

             if scores is None:
                 A__			,						A__					=       logits.topk(a__			,    -1)
                 A__					=       generated.expand(a__			,    *generated.shape[1:])
                 A__			,						A__					=       next_tokens.permute(1			,    0), scores.squeeze(0)
                 if tokens is None:
                     A__					=       next_tokens
                 else:
                     A__					=       tokens.expand(a__			,    *tokens.shape[1:])
                     A__					=       torch.cat((tokens, next_tokens)			,    dim=1)
             else:
                 A__					=       -float(np.inf)
                 A__					=       0
                 A__					=       scores[:, None] + logits
                 seq_lengths[~is_stopped] += 1
                 A__					=       scores_sum / seq_lengths[:, None]
                 A__			,						A__					=       scores_sum_average.view(-1).topk(a__			,    -1)
                 A__					=       next_tokens // scores_sum.shape[1]
                 A__					=       seq_lengths[next_tokens_source]
                 A__					=       next_tokens % scores_sum.shape[1]
                 A__					=       next_tokens.unsqueeze(1)
                 A__					=       tokens[next_tokens_source]
                 A__					=       torch.cat((tokens, next_tokens)			,    dim=1)
                 A__					=       generated[next_tokens_source]
                 A__					=       scores_sum_average * seq_lengths
                 A__					=       is_stopped[next_tokens_source]

             A__					=       self.transformer.transformer.wte(next_tokens.squeeze()).view(generated.shape[0]			,    1			,    -1)
             A__					=       torch.cat((generated, next_token_embed)			,    dim=1)
             A__					=       is_stopped + next_tokens.eq(a__).squeeze()
             if is_stopped.all():
                 break

         A__					=       scores / seq_lengths
         A__					=       scores.argsort(descending=a__)
         # tokens tensors are already padded to max_seq_length
         A__					=       [tokens[i] for i in order]
         A__					=       torch.stack(a__			,    dim=0)
         A__					=       torch.tensor([seq_lengths[i] for i in order]			,    dtype=seq_lengths.dtype)
         return output_texts, seq_lengths
