




"""simple docstring"""

import argparse
import json
from pathlib import Path

import torch
import torchaudio
from datasets import load_dataset
from huggingface_hub import hf_hub_download

from transformers import ASTConfig, ASTFeatureExtractor, ASTForAudioClassification
from transformers.utils import logging


logging.set_verbosity_info()
a         =      logging.get_logger(__name__)






def 						_snake_case					( _snake_case							: str							)   -> Tuple:






      '''simple docstring'''


      _A        =       ASTConfig()

      if "10-10" in model_name:
            pass
      elif "speech-commands" in model_name:
            _A        =       1_28
      elif "12-12" in model_name:
            _A        =       12
            _A        =       12
      elif "14-14" in model_name:
            _A        =       14
            _A        =       14
      elif "16-16" in model_name:
            _A        =       16
            _A        =       16
      else:
            raise ValueError('Model not supported'							)

      _A        =       'huggingface/label-files'
      if "speech-commands" in model_name:
            _A        =       35
            _A        =       'speech-commands-v2-id2label.json'
      else:
            _A        =       5_27
            _A        =       'audioset-id2label.json'

      _A        =       json.load(open(hf_hub_download(_snake_case    ,  _snake_case    ,  repo_type='dataset'							)    ,  'r'							)							)
      _A        =       {int(_snake_case							): v for k, v in idalabel.items()}
      _A        =       idalabel
      _A        =       {v: k for k, v in idalabel.items()}

      return config






def 						_snake_case					( _snake_case							: List[Any]							)   -> Any:






      '''simple docstring'''


      if "module.v" in name:
            _A        =       name.replace('module.v'    ,  'audio_spectrogram_transformer'							)
      if "cls_token" in name:
            _A        =       name.replace('cls_token'    ,  'embeddings.cls_token'							)
      if "dist_token" in name:
            _A        =       name.replace('dist_token'    ,  'embeddings.distillation_token'							)
      if "pos_embed" in name:
            _A        =       name.replace('pos_embed'    ,  'embeddings.position_embeddings'							)
      if "patch_embed.proj" in name:
            _A        =       name.replace('patch_embed.proj'    ,  'embeddings.patch_embeddings.projection'							)
      # transformer blocks
      if "blocks" in name:
            _A        =       name.replace('blocks'    ,  'encoder.layer'							)
      if "attn.proj" in name:
            _A        =       name.replace('attn.proj'    ,  'attention.output.dense'							)
      if "attn" in name:
            _A        =       name.replace('attn'    ,  'attention.self'							)
      if "norm1" in name:
            _A        =       name.replace('norm1'    ,  'layernorm_before'							)
      if "norm2" in name:
            _A        =       name.replace('norm2'    ,  'layernorm_after'							)
      if "mlp.fc1" in name:
            _A        =       name.replace('mlp.fc1'    ,  'intermediate.dense'							)
      if "mlp.fc2" in name:
            _A        =       name.replace('mlp.fc2'    ,  'output.dense'							)
      # final layernorm
      if "audio_spectrogram_transformer.norm" in name:
            _A        =       name.replace('audio_spectrogram_transformer.norm'    ,  'audio_spectrogram_transformer.layernorm'							)
      # classifier head
      if "module.mlp_head.0" in name:
            _A        =       name.replace('module.mlp_head.0'    ,  'classifier.layernorm'							)
      if "module.mlp_head.1" in name:
            _A        =       name.replace('module.mlp_head.1'    ,  'classifier.dense'							)

      return name






def 						_snake_case					( _snake_case							: Optional[Any]    ,  _snake_case							: Union[str, Any]							)   -> List[str]:






      '''simple docstring'''


      for key in orig_state_dict.copy().keys():
            _A        =       orig_state_dict.pop(_snake_case							)

            if "qkv" in key:
                  _A        =       key.split('.'							)
                  _A        =       int(key_split[3]							)
                  _A        =       config.hidden_size
                  if "weight" in key:
                        _A        =       val[:dim, :]
                        _A        =       val[dim : dim * 2, :]
                        _A        =       val[-dim:, :]
                  else:
                        _A        =       val[:dim]
                        _A        =       val[dim : dim * 2]
                        _A        =       val[-dim:]
            else:
                  _A        =       val

      return orig_state_dict






def 						_snake_case					( _snake_case							: Optional[Any]							)   -> int:






      '''simple docstring'''


      _A        =       [
          'module.v.head.weight',
          'module.v.head.bias',
          'module.v.head_dist.weight',
          'module.v.head_dist.bias',
      ]
      for k in ignore_keys:
            state_dict.pop(_snake_case    ,  _snake_case							)






@torch.no_grad()
def 						_snake_case					( _snake_case							: Tuple    ,  _snake_case							: List[Any]    ,  _snake_case							: List[str]=False							)   -> Any:






      '''simple docstring'''


      _A        =       get_audio_spectrogram_transformer_config(_snake_case							)

      _A        =       {
          'ast-finetuned-audioset-10-10-0.4593': (
              'https://www.dropbox.com/s/ca0b1v2nlxzyeb4/audioset_10_10_0.4593.pth?dl=1'
          ),
          'ast-finetuned-audioset-10-10-0.450': (
              'https://www.dropbox.com/s/1tv0hovue1bxupk/audioset_10_10_0.4495.pth?dl=1'
          ),
          'ast-finetuned-audioset-10-10-0.448': (
              'https://www.dropbox.com/s/6u5sikl4b9wo4u5/audioset_10_10_0.4483.pth?dl=1'
          ),
          'ast-finetuned-audioset-10-10-0.448-v2': (
              'https://www.dropbox.com/s/kt6i0v9fvfm1mbq/audioset_10_10_0.4475.pth?dl=1'
          ),
          'ast-finetuned-audioset-12-12-0.447': (
              'https://www.dropbox.com/s/snfhx3tizr4nuc8/audioset_12_12_0.4467.pth?dl=1'
          ),
          'ast-finetuned-audioset-14-14-0.443': (
              'https://www.dropbox.com/s/z18s6pemtnxm4k7/audioset_14_14_0.4431.pth?dl=1'
          ),
          'ast-finetuned-audioset-16-16-0.442': (
              'https://www.dropbox.com/s/mdsa4t1xmcimia6/audioset_16_16_0.4422.pth?dl=1'
          ),
          'ast-finetuned-speech-commands-v2': (
              'https://www.dropbox.com/s/q0tbqpwv44pquwy/speechcommands_10_10_0.9812.pth?dl=1'
          ),
      }

      # load original state_dict
      _A        =       model_name_to_url[model_name]
      _A        =       torch.hub.load_state_dict_from_url(_snake_case    ,  map_location='cpu'							)
      # remove some keys
      remove_keys(_snake_case							)
      # rename some keys
      _A        =       convert_state_dict(_snake_case    ,  _snake_case							)

      # load 🤗 model
      _A        =       ASTForAudioClassification(_snake_case							)
      model.eval()

      model.load_state_dict(_snake_case							)

      # verify outputs on dummy input
      # source: https://github.com/YuanGongND/ast/blob/79e873b8a54d0a3b330dd522584ff2b9926cd581/src/run.py#L62
      _A        =       -4.2677393 if 'speech-commands' not in model_name else -6.845978
      _A        =       4.5689974 if 'speech-commands' not in model_name else 5.5654526
      _A        =       10_24 if 'speech-commands' not in model_name else 1_28
      _A        =       ASTFeatureExtractor(mean=_snake_case    ,  std=_snake_case    ,  max_length=_snake_case							)

      if "speech-commands" in model_name:
            _A        =       load_dataset('speech_commands'    ,  'v0.02'    ,  split='validation'							)
            _A        =       dataset[0]['audio']['array']
      else:
            _A        =       hf_hub_download(
                repo_id='nielsr/audio-spectogram-transformer-checkpoint'    ,  filename='sample_audio.flac'    ,  repo_type='dataset'    ,  )

            _A       ,   _A        =       torchaudio.load(_snake_case							)
            _A        =       waveform.squeeze().numpy()

      _A        =       feature_extractor(_snake_case    ,  sampling_rate=1_60_00    ,  return_tensors='pt'							)

      # forward pass
      _A        =       model(**_snake_case							)
      _A        =       outputs.logits

      if model_name == "ast-finetuned-audioset-10-10-0.4593":
            _A        =       torch.tensor([-0.8760, -7.0042, -8.6602]							)
      elif model_name == "ast-finetuned-audioset-10-10-0.450":
            _A        =       torch.tensor([-1.1986, -7.0903, -8.2718]							)
      elif model_name == "ast-finetuned-audioset-10-10-0.448":
            _A        =       torch.tensor([-2.6128, -8.0080, -9.4344]							)
      elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
            _A        =       torch.tensor([-1.5080, -7.4534, -8.8917]							)
      elif model_name == "ast-finetuned-audioset-12-12-0.447":
            _A        =       torch.tensor([-0.5050, -6.5833, -8.0843]							)
      elif model_name == "ast-finetuned-audioset-14-14-0.443":
            _A        =       torch.tensor([-0.3826, -7.0336, -8.2413]							)
      elif model_name == "ast-finetuned-audioset-16-16-0.442":
            _A        =       torch.tensor([-1.2113, -6.9101, -8.3470]							)
      elif model_name == "ast-finetuned-speech-commands-v2":
            _A        =       torch.tensor([6.1589, -8.0566, -8.7984]							)
      else:
            raise ValueError('Unknown model name'							)
      if not torch.allclose(logits[0, :3]    ,  _snake_case    ,  atol=1E-4							):
            raise ValueError('Logits don\'t match'							)
      print('Looks ok!'							)

      if pytorch_dump_folder_path is not None:
            Path(_snake_case							).mkdir(exist_ok=_snake_case							)
            print(F'''Saving model {model_name} to {pytorch_dump_folder_path}'''							)
            model.save_pretrained(_snake_case							)
            print(F'''Saving feature extractor to {pytorch_dump_folder_path}'''							)
            feature_extractor.save_pretrained(_snake_case							)

      if push_to_hub:
            print('Pushing model and feature extractor to the hub...'							)
            model.push_to_hub(F'''MIT/{model_name}'''							)
            feature_extractor.push_to_hub(F'''MIT/{model_name}'''							)


if __name__ == "__main__":
       a         =      argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           '''--model_name''',
           default='''ast-finetuned-audioset-10-10-0.4593''',
           type=str,
           help='''Name of the Audio Spectrogram Transformer model you\'d like to convert.''',
       )
       parser.add_argument(
           '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
       )
       parser.add_argument(
           '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
       )

       a         =      parser.parse_args()
       convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)







"""simple docstring"""

from dataclasses import dataclass
from typing import Dict, Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput, apply_forward_hook
from .attention_processor import AttentionProcessor, AttnProcessor
from .modeling_utils import ModelMixin
from .vae import Decoder, DecoderOutput, DiagonalGaussianDistribution, Encoder





@dataclass
class     lowercase_	(					__lowerCAmelCase							):



 '''simple docstring'''
 UpperCAmelCase   :					"DiagonalGaussianDistribution"





class     lowercase_	(					__lowerCAmelCase      ,     __lowerCAmelCase							):



 '''simple docstring'''
 UpperCAmelCase   :					List[Any]				  =     True

 @register_to_config
 def __init__(			self	:	List[str]   ,							_UpperCAmelCase	:	int = 3   ,							_UpperCAmelCase	:	int = 3   ,							_UpperCAmelCase	:	Tuple[str] = ("DownEncoderBlock2D",)   ,							_UpperCAmelCase	:	Tuple[str] = ("UpDecoderBlock2D",)   ,							_UpperCAmelCase	:	Tuple[int] = (64,)   ,							_UpperCAmelCase	:	int = 1   ,							_UpperCAmelCase	:	str = "silu"   ,							_UpperCAmelCase	:	int = 4   ,							_UpperCAmelCase	:	int = 32   ,							_UpperCAmelCase	:	int = 32   ,							_UpperCAmelCase	:	float = 0.1_8215   ,							):
       super().__init__()

       # pass init params to Encoder
       _A        =       Encoder(
           in_channels=_UpperCAmelCase   ,							out_channels=_UpperCAmelCase   ,							down_block_types=_UpperCAmelCase   ,							block_out_channels=_UpperCAmelCase   ,							layers_per_block=_UpperCAmelCase   ,							act_fn=_UpperCAmelCase   ,							norm_num_groups=_UpperCAmelCase   ,							double_z=_UpperCAmelCase   ,							)

       # pass init params to Decoder
       _A        =       Decoder(
           in_channels=_UpperCAmelCase   ,							out_channels=_UpperCAmelCase   ,							up_block_types=_UpperCAmelCase   ,							block_out_channels=_UpperCAmelCase   ,							layers_per_block=_UpperCAmelCase   ,							norm_num_groups=_UpperCAmelCase   ,							act_fn=_UpperCAmelCase   ,							)

       _A        =       nn.Convad(2 * latent_channels   ,							2 * latent_channels   ,							1		)
       _A        =       nn.Convad(_UpperCAmelCase   ,							_UpperCAmelCase   ,							1		)

       _A        =       False
       _A        =       False

       # only relevant if vae tiling is enabled
       _A        =       self.config.sample_size
       _A        =       (
           self.config.sample_size[0]
           if isinstance(self.config.sample_size   ,							(list, tuple)		)
           else self.config.sample_size
       )
       _A        =       int(sample_size / (2 ** (len(self.config.block_out_channels		) - 1))		)
       _A        =       0.25

 def       lowerCAmelCase_							(			self	:	Union[str, Any]   ,							_UpperCAmelCase	:	int   ,							_UpperCAmelCase	:	Tuple=False		):
       if isinstance(_UpperCAmelCase   ,							(Encoder, Decoder)		):
             _A        =       value

 def       lowerCAmelCase_							(			self	:	List[str]   ,							_UpperCAmelCase	:	bool = True		):
       _A        =       use_tiling

 def       lowerCAmelCase_							(			self	:	Union[str, Any]		):
       self.enable_tiling(_UpperCAmelCase		)

 def       lowerCAmelCase_							(			self	:	Dict		):
       _A        =       True

 def       lowerCAmelCase_							(			self	:	str		):
       _A        =       False

 @property
 # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors
 def       lowerCAmelCase_							(			self	:	str		):
       _A        =       {}

       def fn_recursive_add_processors(_UpperCAmelCase	:	str   ,							_UpperCAmelCase	:	torch.nn.Module   ,							_UpperCAmelCase	:	Dict[str, AttentionProcessor]		):
             if hasattr(_UpperCAmelCase   ,							'set_processor'		):
                   _A        =       module.processor

             for sub_name, child in module.named_children():
                   fn_recursive_add_processors(F'''{name}.{sub_name}'''   ,							_UpperCAmelCase   ,							_UpperCAmelCase		)

             return processors

       for name, module in self.named_children():
             fn_recursive_add_processors(_UpperCAmelCase   ,							_UpperCAmelCase   ,							_UpperCAmelCase		)

       return processors

 def       lowerCAmelCase_							(			self	:	str   ,							_UpperCAmelCase	:	Union[AttentionProcessor, Dict[str, AttentionProcessor]]		):
       _A        =       len(self.attn_processors.keys()		)

       if isinstance(_UpperCAmelCase   ,							_UpperCAmelCase		) and len(_UpperCAmelCase		) != count:
             raise ValueError(
                 F'''A dict of processors was passed, but the number of processors {len(_UpperCAmelCase		)} does not match the'''
                 F''' number of attention layers: {count}. Please make sure to pass {count} processor classes.'''		)

       def fn_recursive_attn_processor(_UpperCAmelCase	:	str   ,							_UpperCAmelCase	:	torch.nn.Module   ,							_UpperCAmelCase	:	int		):
             if hasattr(_UpperCAmelCase   ,							'set_processor'		):
                   if not isinstance(_UpperCAmelCase   ,							_UpperCAmelCase		):
                         module.set_processor(_UpperCAmelCase		)
                   else:
                         module.set_processor(processor.pop(F'''{name}.processor'''		)		)

             for sub_name, child in module.named_children():
                   fn_recursive_attn_processor(F'''{name}.{sub_name}'''   ,							_UpperCAmelCase   ,							_UpperCAmelCase		)

       for name, module in self.named_children():
             fn_recursive_attn_processor(_UpperCAmelCase   ,							_UpperCAmelCase   ,							_UpperCAmelCase		)

 def       lowerCAmelCase_							(			self	:	List[str]		):
       self.set_attn_processor(AttnProcessor()		)

 @apply_forward_hook
 def       lowerCAmelCase_							(			self	:	int   ,							_UpperCAmelCase	:	torch.FloatTensor   ,							_UpperCAmelCase	:	bool = True		):
       if self.use_tiling and (x.shape[-1] > self.tile_sample_min_size or x.shape[-2] > self.tile_sample_min_size):
             return self.tiled_encode(_UpperCAmelCase   ,							return_dict=_UpperCAmelCase		)

       if self.use_slicing and x.shape[0] > 1:
             _A        =       [self.encoder(_UpperCAmelCase		) for x_slice in x.split(1		)]
             _A        =       torch.cat(_UpperCAmelCase		)
       else:
             _A        =       self.encoder(_UpperCAmelCase		)

       _A        =       self.quant_conv(_UpperCAmelCase		)
       _A        =       DiagonalGaussianDistribution(_UpperCAmelCase		)

       if not return_dict:
             return (posterior,)

       return AutoencoderKLOutput(latent_dist=_UpperCAmelCase		)

 def       lowerCAmelCase_							(			self	:	Any   ,							_UpperCAmelCase	:	torch.FloatTensor   ,							_UpperCAmelCase	:	bool = True		):
       if self.use_tiling and (z.shape[-1] > self.tile_latent_min_size or z.shape[-2] > self.tile_latent_min_size):
             return self.tiled_decode(_UpperCAmelCase   ,							return_dict=_UpperCAmelCase		)

       _A        =       self.post_quant_conv(_UpperCAmelCase		)
       _A        =       self.decoder(_UpperCAmelCase		)

       if not return_dict:
             return (dec,)

       return DecoderOutput(sample=_UpperCAmelCase		)

 @apply_forward_hook
 def       lowerCAmelCase_							(			self	:	str   ,							_UpperCAmelCase	:	torch.FloatTensor   ,							_UpperCAmelCase	:	bool = True		):
       if self.use_slicing and z.shape[0] > 1:
             _A        =       [self._decode(_UpperCAmelCase		).sample for z_slice in z.split(1		)]
             _A        =       torch.cat(_UpperCAmelCase		)
       else:
             _A        =       self._decode(_UpperCAmelCase		).sample

       if not return_dict:
             return (decoded,)

       return DecoderOutput(sample=_UpperCAmelCase		)

 def       lowerCAmelCase_							(			self	:	str   ,							_UpperCAmelCase	:	int   ,							_UpperCAmelCase	:	Dict   ,							_UpperCAmelCase	:	Any		):
       _A        =       min(a.shape[2]   ,							b.shape[2]   ,							_UpperCAmelCase		)
       for y in range(_UpperCAmelCase		):
             _A        =       a[:, :, -blend_extent + y, :] * (1 - y / blend_extent) + b[:, :, y, :] * (y / blend_extent)
       return b

 def       lowerCAmelCase_							(			self	:	Optional[Any]   ,							_UpperCAmelCase	:	List[str]   ,							_UpperCAmelCase	:	List[Any]   ,							_UpperCAmelCase	:	List[Any]		):
       _A        =       min(a.shape[3]   ,							b.shape[3]   ,							_UpperCAmelCase		)
       for x in range(_UpperCAmelCase		):
             _A        =       a[:, :, :, -blend_extent + x] * (1 - x / blend_extent) + b[:, :, :, x] * (x / blend_extent)
       return b

 def       lowerCAmelCase_							(			self	:	str   ,							_UpperCAmelCase	:	torch.FloatTensor   ,							_UpperCAmelCase	:	bool = True		):
       _A        =       int(self.tile_sample_min_size * (1 - self.tile_overlap_factor)		)
       _A        =       int(self.tile_latent_min_size * self.tile_overlap_factor		)
       _A        =       self.tile_latent_min_size - blend_extent

       # Split the image into 512x512 tiles and encode them separately.
       _A        =       []
       for i in range(0   ,							x.shape[2]   ,							_UpperCAmelCase		):
             _A        =       []
             for j in range(0   ,							x.shape[3]   ,							_UpperCAmelCase		):
                   _A        =       x[:, :, i : i + self.tile_sample_min_size, j : j + self.tile_sample_min_size]
                   _A        =       self.encoder(_UpperCAmelCase		)
                   _A        =       self.quant_conv(_UpperCAmelCase		)
                   row.append(_UpperCAmelCase		)
             rows.append(_UpperCAmelCase		)
       _A        =       []
       for i, row in enumerate(_UpperCAmelCase		):
             _A        =       []
             for j, tile in enumerate(_UpperCAmelCase		):
                   # blend the above tile and the left tile
                   # to the current tile and add the current tile to the result row
                   if i > 0:
                         _A        =       self.blend_v(rows[i - 1][j]   ,							_UpperCAmelCase   ,							_UpperCAmelCase		)
                   if j > 0:
                         _A        =       self.blend_h(row[j - 1]   ,							_UpperCAmelCase   ,							_UpperCAmelCase		)
                   result_row.append(tile[:, :, :row_limit, :row_limit]		)
             result_rows.append(torch.cat(_UpperCAmelCase   ,							dim=3		)		)

       _A        =       torch.cat(_UpperCAmelCase   ,							dim=2		)
       _A        =       DiagonalGaussianDistribution(_UpperCAmelCase		)

       if not return_dict:
             return (posterior,)

       return AutoencoderKLOutput(latent_dist=_UpperCAmelCase		)

 def       lowerCAmelCase_							(			self	:	Tuple   ,							_UpperCAmelCase	:	torch.FloatTensor   ,							_UpperCAmelCase	:	bool = True		):
       _A        =       int(self.tile_latent_min_size * (1 - self.tile_overlap_factor)		)
       _A        =       int(self.tile_sample_min_size * self.tile_overlap_factor		)
       _A        =       self.tile_sample_min_size - blend_extent

       # Split z into overlapping 64x64 tiles and decode them separately.
       # The tiles have an overlap to avoid seams between tiles.
       _A        =       []
       for i in range(0   ,							z.shape[2]   ,							_UpperCAmelCase		):
             _A        =       []
             for j in range(0   ,							z.shape[3]   ,							_UpperCAmelCase		):
                   _A        =       z[:, :, i : i + self.tile_latent_min_size, j : j + self.tile_latent_min_size]
                   _A        =       self.post_quant_conv(_UpperCAmelCase		)
                   _A        =       self.decoder(_UpperCAmelCase		)
                   row.append(_UpperCAmelCase		)
             rows.append(_UpperCAmelCase		)
       _A        =       []
       for i, row in enumerate(_UpperCAmelCase		):
             _A        =       []
             for j, tile in enumerate(_UpperCAmelCase		):
                   # blend the above tile and the left tile
                   # to the current tile and add the current tile to the result row
                   if i > 0:
                         _A        =       self.blend_v(rows[i - 1][j]   ,							_UpperCAmelCase   ,							_UpperCAmelCase		)
                   if j > 0:
                         _A        =       self.blend_h(row[j - 1]   ,							_UpperCAmelCase   ,							_UpperCAmelCase		)
                   result_row.append(tile[:, :, :row_limit, :row_limit]		)
             result_rows.append(torch.cat(_UpperCAmelCase   ,							dim=3		)		)

       _A        =       torch.cat(_UpperCAmelCase   ,							dim=2		)
       if not return_dict:
             return (dec,)

       return DecoderOutput(sample=_UpperCAmelCase		)



 def       lowerCAmelCase_							(			self	:	List[str]   ,							_UpperCAmelCase	:	torch.FloatTensor   ,							_UpperCAmelCase	:	bool = False   ,							_UpperCAmelCase	:	bool = True   ,							_UpperCAmelCase	:	Optional[torch.Generator] = None   ,							):
       _A        =       sample
       _A        =       self.encode(_UpperCAmelCase		).latent_dist
       if sample_posterior:
             _A        =       posterior.sample(generator=_UpperCAmelCase		)
       else:
             _A        =       posterior.mode()
       _A        =       self.decode(_UpperCAmelCase		).sample

       if not return_dict:
             return (dec,)

       return DecoderOutput(sample=_UpperCAmelCase		)

