code: 
  
  
  
  
  
  
  import argparse
  import os
  
  import align
  import numpy as np
  import requests
  import tensorflow as tf
  import torch
  from PIL import Image
  from tokenizer import Tokenizer
  
  from transformers import (
      AlignConfig,
      AlignModel,
      AlignProcessor,
      BertConfig,
      BertTokenizer,
      EfficientNetConfig,
      EfficientNetImageProcessor,
  )
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  lowerCamelCase			:							List[Any]       =logging.get_logger(__name__)
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase    )				->			List[str]:
       UpperCamelCase__    :     Tuple        =						tf.image.resize(__lowerCAmelCase      ,					(346, 346)    )
       UpperCamelCase__    :     List[Any]        =						tf.image.crop_to_bounding_box(__lowerCAmelCase      ,					(346 - 289) // 2      ,					(346 - 289) // 2      ,					289      ,					289    )
       return image
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      )				->			Optional[int]:
       UpperCamelCase__    :     Any        =						EfficientNetConfig.from_pretrained("google/efficientnet-b7"    )
       UpperCamelCase__    :     int        =						289
       UpperCamelCase__    :     Tuple        =						640
       UpperCamelCase__    :     Union[str, Any]        =						{"0": "LABEL_0", "1": "LABEL_1"}
       UpperCamelCase__    :     Any        =						{"LABEL_0": 0, "LABEL_1": 1}
       UpperCamelCase__    :     List[str]        =						[]
  
       UpperCamelCase__    :     List[str]        =						BertConfig()
       UpperCamelCase__    :     Any        =						AlignConfig.from_text_vision_configs(
           text_config=__lowerCAmelCase      ,					vision_config=__lowerCAmelCase      ,					projection_dim=640    )
       return config
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      )				->			List[str]:
       UpperCamelCase__    :     List[str]        =						"http://images.cocodataset.org/val2017/000000039769.jpg"
       UpperCamelCase__    :     List[Any]        =						Image.open(requests.get(__lowerCAmelCase      ,					stream=__lowerCAmelCase    ).raw    )
       return im
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      )				->			Optional[int]:
       UpperCamelCase__    :     Any        =						EfficientNetImageProcessor(
           do_center_crop=__lowerCAmelCase      ,					rescale_factor=1 / 1_2_7.5      ,					rescale_offset=__lowerCAmelCase      ,					do_normalize=__lowerCAmelCase      ,					include_top=__lowerCAmelCase      ,					resample=Image.BILINEAR      ,					)
       UpperCamelCase__    :     Tuple        =						BertTokenizer.from_pretrained("bert-base-uncased"    )
       UpperCamelCase__    :     int        =						64
       UpperCamelCase__    :     Dict        =						AlignProcessor(image_processor=__lowerCAmelCase      ,					tokenizer=__lowerCAmelCase    )
       return processor
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase    )				->			Optional[Any]:
       # EfficientNet image encoder
       UpperCamelCase__    :     List[Any]        =						[v.split("_"    )[0].split("block"    )[1] for v in original_param_names if v.startswith("block"    )]
       UpperCamelCase__    :     Dict        =						list(set(__lowerCAmelCase    )    )
       UpperCamelCase__    :     Optional[int]        =						sorted(__lowerCAmelCase    )
       UpperCamelCase__    :     List[Any]        =						len(__lowerCAmelCase    )
       UpperCamelCase__    :     Optional[int]        =						{b: str(__lowerCAmelCase    ) for b, i in zip(__lowerCAmelCase      ,					range(__lowerCAmelCase    )    )}
  
       UpperCamelCase__    :     str        =						[]
       rename_keys.append(("stem_conv/kernel:0", "embeddings.convolution.weight")    )
       rename_keys.append(("stem_bn/gamma:0", "embeddings.batchnorm.weight")    )
       rename_keys.append(("stem_bn/beta:0", "embeddings.batchnorm.bias")    )
       rename_keys.append(("stem_bn/moving_mean:0", "embeddings.batchnorm.running_mean")    )
       rename_keys.append(("stem_bn/moving_variance:0", "embeddings.batchnorm.running_var")    )
  
       for b in block_names:
            UpperCamelCase__    :     List[str]        =						block_name_mapping[b]
            rename_keys.append((f'block{b}_expand_conv/kernel:0', f'encoder.blocks.{hf_b}.expansion.expand_conv.weight')    )
            rename_keys.append((f'block{b}_expand_bn/gamma:0', f'encoder.blocks.{hf_b}.expansion.expand_bn.weight')    )
            rename_keys.append((f'block{b}_expand_bn/beta:0', f'encoder.blocks.{hf_b}.expansion.expand_bn.bias')    )
            rename_keys.append(
                (f'block{b}_expand_bn/moving_mean:0', f'encoder.blocks.{hf_b}.expansion.expand_bn.running_mean')    )
            rename_keys.append(
                (f'block{b}_expand_bn/moving_variance:0', f'encoder.blocks.{hf_b}.expansion.expand_bn.running_var')    )
            rename_keys.append(
                (f'block{b}_dwconv/depthwise_kernel:0', f'encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight')    )
            rename_keys.append((f'block{b}_bn/gamma:0', f'encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight')    )
            rename_keys.append((f'block{b}_bn/beta:0', f'encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias')    )
            rename_keys.append(
                (f'block{b}_bn/moving_mean:0', f'encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean')    )
            rename_keys.append(
                (f'block{b}_bn/moving_variance:0', f'encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var')    )
  
            rename_keys.append((f'block{b}_se_reduce/kernel:0', f'encoder.blocks.{hf_b}.squeeze_excite.reduce.weight')    )
            rename_keys.append((f'block{b}_se_reduce/bias:0', f'encoder.blocks.{hf_b}.squeeze_excite.reduce.bias')    )
            rename_keys.append((f'block{b}_se_expand/kernel:0', f'encoder.blocks.{hf_b}.squeeze_excite.expand.weight')    )
            rename_keys.append((f'block{b}_se_expand/bias:0', f'encoder.blocks.{hf_b}.squeeze_excite.expand.bias')    )
            rename_keys.append(
                (f'block{b}_project_conv/kernel:0', f'encoder.blocks.{hf_b}.projection.project_conv.weight')    )
            rename_keys.append((f'block{b}_project_bn/gamma:0', f'encoder.blocks.{hf_b}.projection.project_bn.weight')    )
            rename_keys.append((f'block{b}_project_bn/beta:0', f'encoder.blocks.{hf_b}.projection.project_bn.bias')    )
            rename_keys.append(
                (f'block{b}_project_bn/moving_mean:0', f'encoder.blocks.{hf_b}.projection.project_bn.running_mean')    )
            rename_keys.append(
                (f'block{b}_project_bn/moving_variance:0', f'encoder.blocks.{hf_b}.projection.project_bn.running_var')    )
  
       UpperCamelCase__    :     str        =						{}
       for item in rename_keys:
            if item[0] in original_param_names:
                 UpperCamelCase__    :     Optional[Any]        =						"vision_model." + item[1]
  
      # BERT text encoder
       UpperCamelCase__    :     List[Any]        =						[]
       UpperCamelCase__    :     Union[str, Any]        =						"tf_bert_model/bert"
       UpperCamelCase__    :     Dict        =						"text_model"
       for i in range(12    ):
            rename_keys.append(
                (
                    f'{old}/encoder/layer_._{i}/attention/self/query/kernel:0',
                    f'{new}.encoder.layer.{i}.attention.self.query.weight',
                )    )
            rename_keys.append(
                (
                    f'{old}/encoder/layer_._{i}/attention/self/query/bias:0',
                    f'{new}.encoder.layer.{i}.attention.self.query.bias',
                )    )
            rename_keys.append(
                (
                    f'{old}/encoder/layer_._{i}/attention/self/key/kernel:0',
                    f'{new}.encoder.layer.{i}.attention.self.key.weight',
                )    )
            rename_keys.append(
                (
                    f'{old}/encoder/layer_._{i}/attention/self/key/bias:0',
                    f'{new}.encoder.layer.{i}.attention.self.key.bias',
                )    )
            rename_keys.append(
                (
                    f'{old}/encoder/layer_._{i}/attention/self/value/kernel:0',
                    f'{new}.encoder.layer.{i}.attention.self.value.weight',
                )    )
            rename_keys.append(
                (
                    f'{old}/encoder/layer_._{i}/attention/self/value/bias:0',
                    f'{new}.encoder.layer.{i}.attention.self.value.bias',
                )    )
            rename_keys.append(
                (
                    f'{old}/encoder/layer_._{i}/attention/output/dense/kernel:0',
                    f'{new}.encoder.layer.{i}.attention.output.dense.weight',
                )    )
            rename_keys.append(
                (
                    f'{old}/encoder/layer_._{i}/attention/output/dense/bias:0',
                    f'{new}.encoder.layer.{i}.attention.output.dense.bias',
                )    )
            rename_keys.append(
                (
                    f'{old}/encoder/layer_._{i}/attention/output/LayerNorm/gamma:0',
                    f'{new}.encoder.layer.{i}.attention.output.LayerNorm.weight',
                )    )
            rename_keys.append(
                (
                    f'{old}/encoder/layer_._{i}/attention/output/LayerNorm/beta:0',
                    f'{new}.encoder.layer.{i}.attention.output.LayerNorm.bias',
                )    )
            rename_keys.append(
                (
                    f'{old}/encoder/layer_._{i}/intermediate/dense/kernel:0',
                    f'{new}.encoder.layer.{i}.intermediate.dense.weight',
                )    )
            rename_keys.append(
                (
                    f'{old}/encoder/layer_._{i}/intermediate/dense/bias:0',
                    f'{new}.encoder.layer.{i}.intermediate.dense.bias',
                )    )
            rename_keys.append(
                (f'{old}/encoder/layer_._{i}/output/dense/kernel:0', f'{new}.encoder.layer.{i}.output.dense.weight')    )
            rename_keys.append(
                (f'{old}/encoder/layer_._{i}/output/dense/bias:0', f'{new}.encoder.layer.{i}.output.dense.bias')    )
            rename_keys.append(
                (f'{old}/encoder/layer_._{i}/output/LayerNorm/gamma:0', f'{new}.encoder.layer.{i}.output.LayerNorm.weight')    )
            rename_keys.append(
                (f'{old}/encoder/layer_._{i}/output/LayerNorm/beta:0', f'{new}.encoder.layer.{i}.output.LayerNorm.bias')    )
  
       rename_keys.append((f'{old}/embeddings/word_embeddings/weight:0', f'{new}.embeddings.word_embeddings.weight')    )
       rename_keys.append(
           (f'{old}/embeddings/position_embeddings/embeddings:0', f'{new}.embeddings.position_embeddings.weight')    )
       rename_keys.append(
           (f'{old}/embeddings/token_type_embeddings/embeddings:0', f'{new}.embeddings.token_type_embeddings.weight')    )
       rename_keys.append((f'{old}/embeddings/LayerNorm/gamma:0', f'{new}.embeddings.LayerNorm.weight')    )
       rename_keys.append((f'{old}/embeddings/LayerNorm/beta:0', f'{new}.embeddings.LayerNorm.bias')    )
  
       rename_keys.append((f'{old}/pooler/dense/kernel:0', f'{new}.pooler.dense.weight')    )
       rename_keys.append((f'{old}/pooler/dense/bias:0', f'{new}.pooler.dense.bias')    )
       rename_keys.append(("dense/kernel:0", "text_projection.weight")    )
       rename_keys.append(("dense/bias:0", "text_projection.bias")    )
       rename_keys.append(("dense/bias:0", "text_projection.bias")    )
       rename_keys.append(("temperature:0", "temperature")    )
  
       for item in rename_keys:
            if item[0] in original_param_names:
                 UpperCamelCase__    :     Dict        =						item[1]
       return key_mapping
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase    )				->			str:
       list(hf_params.keys()    )
  
       for key, value in tf_params.items():
            if key not in key_mapping:
                 continue
  
            UpperCamelCase__    :     Tuple        =						key_mapping[key]
            if "_conv" in key and "kernel" in key:
                 UpperCamelCase__    :     int        =						torch.from_numpy(__lowerCAmelCase    ).permute(3      ,					2      ,					0      ,					1    )
            elif "embeddings" in key:
                 UpperCamelCase__    :     Any        =						torch.from_numpy(__lowerCAmelCase    )
            elif "depthwise_kernel" in key:
                 UpperCamelCase__    :     Union[str, Any]        =						torch.from_numpy(__lowerCAmelCase    ).permute(2      ,					3      ,					0      ,					1    )
            elif "kernel" in key:
                 UpperCamelCase__    :     str        =						torch.from_numpy(np.transpose(__lowerCAmelCase    )    )
            elif "temperature" in key:
                 UpperCamelCase__    :     Tuple        =						value
            elif "bn/gamma" or "bn/beta" in key:
                 UpperCamelCase__    :     Optional[int]        =						torch.from_numpy(np.transpose(__lowerCAmelCase    )    ).squeeze()
            else:
                 UpperCamelCase__    :     Any        =						torch.from_numpy(__lowerCAmelCase    )
  
            # Replace HF parameters with original TF model parameters
            hf_params[hf_key].copy_(__lowerCAmelCase    )
  
  
  
  
  
  
  
  @torch.no_grad()
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase    )				->			int:
       UpperCamelCase__    :     Tuple        =						64
       UpperCamelCase__    :     Tuple        =						Tokenizer(__lowerCAmelCase    )
       UpperCamelCase__    :     List[Any]        =						align.Align("efficientnet-b7"      ,					"bert-base"      ,					640      ,					__lowerCAmelCase      ,					tok.get_vocab_size()    )
       original_model.compile()
       original_model.load_weights(__lowerCAmelCase    )
  
       UpperCamelCase__    :     List[str]        =						original_model.trainable_variables
       UpperCamelCase__    :     str        =						original_model.non_trainable_variables
       UpperCamelCase__    :     Union[str, Any]        =						{param.name: param.numpy() for param in tf_params}
       for param in tf_non_train_params:
            UpperCamelCase__    :     Dict        =						param.numpy()
       UpperCamelCase__    :     int        =						list(tf_params.keys()    )
  
       # Load HuggingFace model
       UpperCamelCase__    :     Optional[Any]        =						get_align_config()
       UpperCamelCase__    :     str        =						AlignModel(__lowerCAmelCase    ).eval()
       UpperCamelCase__    :     str        =						hf_model.state_dict()
  
       # Create src-to-dst parameter name mapping dictionary
       print("Converting parameters..."    )
       UpperCamelCase__    :     Any        =						rename_keys(__lowerCAmelCase    )
       replace_params(__lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase    )
  
       # Initialize processor
       UpperCamelCase__    :     Optional[Any]        =						get_processor()
       UpperCamelCase__    :     Dict        =						processor(
           images=prepare_img()      ,					text="A picture of a cat"      ,					padding="max_length"      ,					max_length=64      ,					return_tensors="pt"    )
  
       # HF model inference
       hf_model.eval()
       with torch.no_grad():
            UpperCamelCase__    :     Optional[Any]        =						hf_model(**__lowerCAmelCase    )
  
       UpperCamelCase__    :     Dict        =						outputs.image_embeds.detach().numpy()
       UpperCamelCase__    :     List[Any]        =						outputs.text_embeds.detach().numpy()
  
       # Original model inference
       UpperCamelCase__    :     str        =						False
       UpperCamelCase__    :     Tuple        =						EfficientNetImageProcessor(
           do_center_crop=__lowerCAmelCase      ,					do_rescale=__lowerCAmelCase      ,					do_normalize=__lowerCAmelCase      ,					include_top=__lowerCAmelCase      ,					resample=Image.BILINEAR      ,					)
       UpperCamelCase__    :     List[Any]        =						tf_image_processor(images=prepare_img()      ,					return_tensors="tf"      ,					data_format="channels_last"    )["pixel_values"]
       UpperCamelCase__    :     Union[str, Any]        =						tok(tf.constant(["A picture of a cat"]    )    )
  
       UpperCamelCase__    :     int        =						original_model.image_encoder(__lowerCAmelCase      ,					training=__lowerCAmelCase    )
       UpperCamelCase__    :     Dict        =						original_model.text_encoder(__lowerCAmelCase      ,					training=__lowerCAmelCase    )
  
       UpperCamelCase__    :     str        =						tf.nn.la_normalize(__lowerCAmelCase      ,					axis=-1    )
       UpperCamelCase__    :     Dict        =						tf.nn.la_normalize(__lowerCAmelCase      ,					axis=-1    )
  
       # Check whether original and HF model outputs match  -> np.allclose
       if not np.allclose(__lowerCAmelCase      ,					__lowerCAmelCase      ,					atol=1E-3    ):
            raise ValueError("The predicted image features are not the same."    )
       if not np.allclose(__lowerCAmelCase      ,					__lowerCAmelCase      ,					atol=1E-3    ):
            raise ValueError("The predicted text features are not the same."    )
       print("Model outputs match!"    )
  
       if save_model:
            # Create folder to save model
            if not os.path.isdir(__lowerCAmelCase    ):
                 os.mkdir(__lowerCAmelCase    )
            # Save converted model and image processor
            hf_model.save_pretrained(__lowerCAmelCase    )
            processor.save_pretrained(__lowerCAmelCase    )
  
       if push_to_hub:
            # Push model and image processor to hub
            print("Pushing converted ALIGN to the hub..."    )
            processor.push_to_hub("align-base"    )
            hf_model.push_to_hub("align-base"    )
  
  
  if __name__ == "__main__":
   lowerCamelCase			:							Any       =argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       '''--checkpoint_path''',
       default='''./weights/model-weights''',
       type=str,
       help='''Path to the pretrained TF ALIGN checkpoint.''',
   )
   parser.add_argument(
       '''--pytorch_dump_folder_path''',
       default='''hf_model''',
       type=str,
       help='''Path to the output PyTorch model directory.''',
   )
   parser.add_argument('''--save_model''', action='''store_true''', help='''Save model to local''')
   parser.add_argument('''--push_to_hub''', action='''store_true''', help='''Push model and image processor to the hub''')
  
   lowerCamelCase			:							List[str]       =parser.parse_args()
   convert_align_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  import numpy as np  # noqa: E402
  
  from ...configuration_utils import ConfigMixin, register_to_config
  from ...schedulers.scheduling_utils import SchedulerMixin
  
  
  try:
   import librosa  # noqa: E402
  
   lowerCamelCase			:							List[str]       =True
   lowerCamelCase			:							Dict       =''''''
  except Exception as e:
   lowerCamelCase			:							str       =False
   lowerCamelCase			:							List[Any]       =(
       F"""Cannot import librosa because {e}. Make sure to correctly install librosa to be able to install it."""
   )
  
  
  from PIL import Image  # noqa: E402
  
  
  
  
  
  class     __a						(					A__ ,     A__ ):
   _lowerCAmelCase : Optional[Any] 				=				'''mel_config.json'''
  
  
  
  
  
  
  
   @register_to_config
   def __init__(	self      :     Any							,     SCREAMING_SNAKE_CASE      :     int = 2_56							,     SCREAMING_SNAKE_CASE      :     int = 2_56							,     SCREAMING_SNAKE_CASE      :     int = 2_20_50							,     SCREAMING_SNAKE_CASE      :     int = 20_48							,     SCREAMING_SNAKE_CASE      :     int = 5_12							,     SCREAMING_SNAKE_CASE      :     int = 80							,     SCREAMING_SNAKE_CASE      :     int = 32							,     ):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        UpperCamelCase__    :     str        =						hop_length
        UpperCamelCase__    :     Optional[Any]        =						sample_rate
        UpperCamelCase__    :     Dict        =						n_fft
        UpperCamelCase__    :     str        =						top_db
        UpperCamelCase__    :     Optional[Any]        =						n_iter
        self.set_resolution(SCREAMING_SNAKE_CASE							,     SCREAMING_SNAKE_CASE		)
        UpperCamelCase__    :     str        =						None
  
        if not _librosa_can_be_imported:
             raise ValueError(_import_error		)
  
  
  
  
  
  
  
   def       __lowercase      (	self      :     Tuple							,     SCREAMING_SNAKE_CASE      :     int							,     SCREAMING_SNAKE_CASE      :     int		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        UpperCamelCase__    :     Dict        =						x_res
        UpperCamelCase__    :     Dict        =						y_res
        UpperCamelCase__    :     Dict        =						self.y_res
        UpperCamelCase__    :     Any        =						self.x_res * self.hop_length - 1
  
  
  
  
  
  
  
   def       __lowercase      (	self      :     str							,     SCREAMING_SNAKE_CASE      :     str = None							,     SCREAMING_SNAKE_CASE      :     np.ndarray = None		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        if audio_file is not None:
             UpperCamelCase__       ,  UpperCamelCase__    :     int        =						librosa.load(SCREAMING_SNAKE_CASE							,     mono=SCREAMING_SNAKE_CASE							,     sr=self.sr		)
        else:
             UpperCamelCase__    :     List[Any]        =						raw_audio
  
        # Pad with silence if necessary.
        if len(self.audio		) < self.x_res * self.hop_length:
             UpperCamelCase__    :     List[Any]        =						np.concatenate([self.audio, np.zeros((self.x_res * self.hop_length - len(self.audio		),)		)]		)
  
  
  
  
  
  
  
   def       __lowercase      (	self      :     List[Any]		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        return len(self.audio		) // self.slice_size
  
  
  
  
  
  
  
   def       __lowercase      (	self      :     int							,     SCREAMING_SNAKE_CASE      :     int = 0		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        return self.audio[self.slice_size * slice : self.slice_size * (slice + 1)]
  
  
  
  
  
  
  
   def       __lowercase      (	self      :     Tuple		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        return self.sr
  
  
  
  
  
  
  
   def       __lowercase      (	self      :     Union[str, Any]							,     SCREAMING_SNAKE_CASE      :     int		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        UpperCamelCase__    :     Optional[int]        =						librosa.feature.melspectrogram(
            y=self.get_audio_slice(SCREAMING_SNAKE_CASE		)							,     sr=self.sr							,     n_fft=self.n_fft							,     hop_length=self.hop_length							,     n_mels=self.n_mels		)
        UpperCamelCase__    :     Tuple        =						librosa.power_to_db(SCREAMING_SNAKE_CASE							,     ref=np.max							,     top_db=self.top_db		)
        UpperCamelCase__    :     Optional[Any]        =						(((log_S + self.top_db) * 2_55 / self.top_db).clip(0							,     2_55		) + 0.5).astype(np.uinta		)
        UpperCamelCase__    :     Optional[Any]        =						Image.fromarray(SCREAMING_SNAKE_CASE		)
        return image
  
  
  
  
  
  
  
   def       __lowercase      (	self      :     List[Any]							,     SCREAMING_SNAKE_CASE      :     Image.Image		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        UpperCamelCase__    :     Optional[Any]        =						np.frombuffer(image.tobytes()							,     dtype="uint8"		).reshape((image.height, image.width)		)
        UpperCamelCase__    :     str        =						bytedata.astype("float"		) * self.top_db / 2_55 - self.top_db
        UpperCamelCase__    :     Any        =						librosa.db_to_power(SCREAMING_SNAKE_CASE		)
        UpperCamelCase__    :     Tuple        =						librosa.feature.inverse.mel_to_audio(
            SCREAMING_SNAKE_CASE							,     sr=self.sr							,     n_fft=self.n_fft							,     hop_length=self.hop_length							,     n_iter=self.n_iter		)
        return audio