






"""simple docstring"""




import numpy as np

import datasets


_snake_case          =   '\nCompute the Mahalanobis Distance\n\nMahalonobis distance is the distance between a point and a distribution.\nAnd not between two distinct points. It is effectively a multivariate equivalent of the Euclidean distance.\nIt was introduced by Prof. P. C. Mahalanobis in 1936\nand has been used in various statistical applications ever since\n[source: https://www.machinelearningplus.com/statistics/mahalanobis-distance/]\n'

_snake_case          =   '\\n@article{de2000mahalanobis,\n  title={The mahalanobis distance},\n  author={De Maesschalck, Roy and Jouan-Rimbaud, Delphine and Massart, D{\'e}sir{\'e} L},\n  journal={Chemometrics and intelligent laboratory systems},\n  volume={50},\n  number={1},\n  pages={1--18},\n  year={2000},\n  publisher={Elsevier}\n}\n'

_snake_case          =   '\nArgs:\n    X: List of datapoints to be compared with the `reference_distribution`.\n    reference_distribution: List of datapoints from the reference distribution we want to compare to.\nReturns:\n    mahalanobis: The Mahalonobis distance for each datapoint in `X`.\nExamples:\n\n    >>> mahalanobis_metric = datasets.load_metric("mahalanobis")\n    >>> results = mahalanobis_metric.compute(reference_distribution=[[0, 1], [1, 0]], X=[[0, 1]])\n    >>> print(results)\n    {\'mahalanobis\': array([0.5])}\n'






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION		,     _KWARGS_DESCRIPTION      )
class        UpperCamelCase			(	datasets.Metric      ):


 def _lowercase	(     self		:						Union[str, Any]							)					->       Optional[int]:
   return datasets.MetricInfo(
       description=_DESCRIPTION							,						citation=_CITATION							,						inputs_description=_KWARGS_DESCRIPTION							,						features=datasets.Features(
           {
               """X""": datasets.Sequence(datasets.Value("""float"""							,						id="""sequence"""							)							,						id="""X"""							),
           }							)							,						)







 def _lowercase	(     self		:						str							,						UpperCAmelCase__		:						List[Any]							,						UpperCAmelCase__		:						Optional[Any]							)					->       Union[str, Any]:
   _a  :       List[Any]             =	np.array(__UpperCAmelCase							)
   _a  :       Tuple             =	np.array(__UpperCAmelCase							)

   # Assert that arrays are 2D
   if len(X.shape							) != 2:
     raise ValueError("""Expected `X` to be a 2D vector"""							)
   if len(reference_distribution.shape							) != 2:
     raise ValueError("""Expected `reference_distribution` to be a 2D vector"""							)
   if reference_distribution.shape[0] < 2:
     raise ValueError(
         """Expected `reference_distribution` to be a 2D vector with more than one element in the first dimension"""							)

   # Get mahalanobis distance for each prediction
   _a  :       Any             =	X - np.mean(__UpperCAmelCase							)
   _a  :       Optional[int]             =	np.cov(reference_distribution.T							)
   try:
     _a  :       Any             =	np.linalg.inv(__UpperCAmelCase							)
   except np.linalg.LinAlgError:
     _a  :       Any             =	np.linalg.pinv(__UpperCAmelCase							)
   _a  :       Optional[int]             =	np.dot(__UpperCAmelCase							,						__UpperCAmelCase							)
   _a  :       Dict             =	np.dot(__UpperCAmelCase							,						X_minus_mu.T							).diagonal()

   return {"mahalanobis": mahal_dist}


import argparse
import os

import jax as jnp
import numpy as onp
import torch
import torch.nn as nn
from music_spectrogram_diffusion import inference
from tax import checkpoints

from diffusers import DDPMScheduler, OnnxRuntimeModel, SpectrogramDiffusionPipeline
from diffusers.pipelines.spectrogram_diffusion import SpectrogramContEncoder, SpectrogramNotesEncoder, TaFilmDecoder


UpperCamelCase__											=					'base_with_context'




def    lowerCAmelCase_ (     __A,  __A							)     ->				int:







      '''simple docstring'''


      UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(weights["token_embedder"]["embedding"]							)							)
      UpperCAmelCase__								=  nn.Parameter(
          torch.FloatTensor(weights["Embed_0"]["embedding"]							),  requires_grad=__A							)
      for lyr_num, lyr in enumerate(model.encoders							):
            UpperCAmelCase__								=  weights[f"""layers_{lyr_num}"""]
            UpperCAmelCase__								=  nn.Parameter(
                torch.FloatTensor(ly_weight["pre_attention_layer_norm"]["scale"]							)							)

            UpperCAmelCase__								=  ly_weight["attention"]
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(attention_weights["query"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(attention_weights["key"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(attention_weights["value"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(attention_weights["out"]["kernel"].T							)							)

            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(ly_weight["pre_mlp_layer_norm"]["scale"]							)							)

            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wi_0"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wi_1"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wo"]["kernel"].T							)							)

      UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(weights["encoder_norm"]["scale"]							)							)
      return model




def    lowerCAmelCase_ (     __A,  __A							)     ->				Tuple:







      '''simple docstring'''


      UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(weights["input_proj"]["kernel"].T							)							)

      UpperCAmelCase__								=  nn.Parameter(
          torch.FloatTensor(weights["Embed_0"]["embedding"]							),  requires_grad=__A							)

      for lyr_num, lyr in enumerate(model.encoders							):
            UpperCAmelCase__								=  weights[f"""layers_{lyr_num}"""]
            UpperCAmelCase__								=  ly_weight["attention"]

            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(attention_weights["query"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(attention_weights["key"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(attention_weights["value"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(attention_weights["out"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(
                torch.FloatTensor(ly_weight["pre_attention_layer_norm"]["scale"]							)							)

            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wi_0"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wi_1"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wo"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(ly_weight["pre_mlp_layer_norm"]["scale"]							)							)

      UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(weights["encoder_norm"]["scale"]							)							)

      return model




def    lowerCAmelCase_ (     __A,  __A							)     ->				List[Any]:







      '''simple docstring'''


      UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(weights["time_emb_dense0"]["kernel"].T							)							)
      UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(weights["time_emb_dense1"]["kernel"].T							)							)

      UpperCAmelCase__								=  nn.Parameter(
          torch.FloatTensor(weights["Embed_0"]["embedding"]							),  requires_grad=__A							)

      UpperCAmelCase__								=  nn.Parameter(
          torch.FloatTensor(weights["continuous_inputs_projection"]["kernel"].T							)							)

      for lyr_num, lyr in enumerate(model.decoders							):
            UpperCAmelCase__								=  weights[f"""layers_{lyr_num}"""]
            UpperCAmelCase__								=  nn.Parameter(
                torch.FloatTensor(ly_weight["pre_self_attention_layer_norm"]["scale"]							)							)

            UpperCAmelCase__								=  nn.Parameter(
                torch.FloatTensor(ly_weight["FiLMLayer_0"]["DenseGeneral_0"]["kernel"].T							)							)

            UpperCAmelCase__								=  ly_weight["self_attention"]
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(attention_weights["query"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(attention_weights["key"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(attention_weights["value"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(attention_weights["out"]["kernel"].T							)							)

            UpperCAmelCase__								=  ly_weight["MultiHeadDotProductAttention_0"]
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(attention_weights["query"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(attention_weights["key"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(attention_weights["value"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(attention_weights["out"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(
                torch.FloatTensor(ly_weight["pre_cross_attention_layer_norm"]["scale"]							)							)

            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(ly_weight["pre_mlp_layer_norm"]["scale"]							)							)
            UpperCAmelCase__								=  nn.Parameter(
                torch.FloatTensor(ly_weight["FiLMLayer_1"]["DenseGeneral_0"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wi_0"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wi_1"]["kernel"].T							)							)
            UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wo"]["kernel"].T							)							)

      UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(weights["decoder_norm"]["scale"]							)							)

      UpperCAmelCase__								=  nn.Parameter(torch.FloatTensor(weights["spec_out_dense"]["kernel"].T							)							)

      return model




def    lowerCAmelCase_ (     __A							)     ->				int:







      '''simple docstring'''


      UpperCAmelCase__								=  checkpoints.load_tax_checkpoint(args.checkpoint_path							)
      UpperCAmelCase__								=  jnp.tree_util.tree_map(onp.array,  __A							)

      UpperCAmelCase__								=  [
          "from __gin__ import dynamic_registration",
          "from music_spectrogram_diffusion.models.diffusion import diffusion_utils",
          "diffusion_utils.ClassifierFreeGuidanceConfig.eval_condition_weight = 2.0",
          "diffusion_utils.DiffusionConfig.classifier_free_guidance = @diffusion_utils.ClassifierFreeGuidanceConfig()",
      ]

      UpperCAmelCase__								=  os.path.join(args.checkpoint_path,  "..",  "config.gin"							)
      UpperCAmelCase__								=  inference.parse_training_gin_file(__A,  __A							)
      UpperCAmelCase__								=  inference.InferenceModel(args.checkpoint_path,  __A							)

      UpperCAmelCase__								=  DDPMScheduler(beta_schedule="squaredcos_cap_v2",  variance_type="fixed_large"							)

      UpperCAmelCase__								=  SpectrogramNotesEncoder(
          max_length=synth_model.sequence_length["inputs"],  vocab_size=synth_model.model.module.config.vocab_size,  d_model=synth_model.model.module.config.emb_dim,  dropout_rate=synth_model.model.module.config.dropout_rate,  num_layers=synth_model.model.module.config.num_encoder_layers,  num_heads=synth_model.model.module.config.num_heads,  d_kv=synth_model.model.module.config.head_dim,  d_ff=synth_model.model.module.config.mlp_dim,  feed_forward_proj="gated-gelu",  )

      UpperCAmelCase__								=  SpectrogramContEncoder(
          input_dims=synth_model.audio_codec.n_dims,  targets_context_length=synth_model.sequence_length["targets_context"],  d_model=synth_model.model.module.config.emb_dim,  dropout_rate=synth_model.model.module.config.dropout_rate,  num_layers=synth_model.model.module.config.num_encoder_layers,  num_heads=synth_model.model.module.config.num_heads,  d_kv=synth_model.model.module.config.head_dim,  d_ff=synth_model.model.module.config.mlp_dim,  feed_forward_proj="gated-gelu",  )

      UpperCAmelCase__								=  TaFilmDecoder(
          input_dims=synth_model.audio_codec.n_dims,  targets_length=synth_model.sequence_length["targets_context"],  max_decoder_noise_time=synth_model.model.module.config.max_decoder_noise_time,  d_model=synth_model.model.module.config.emb_dim,  num_layers=synth_model.model.module.config.num_decoder_layers,  num_heads=synth_model.model.module.config.num_heads,  d_kv=synth_model.model.module.config.head_dim,  d_ff=synth_model.model.module.config.mlp_dim,  dropout_rate=synth_model.model.module.config.dropout_rate,  )

      UpperCAmelCase__								=  load_notes_encoder(ta_checkpoint["target"]["token_encoder"],  __A							)
      UpperCAmelCase__								=  load_continuous_encoder(ta_checkpoint["target"]["continuous_encoder"],  __A							)
      UpperCAmelCase__								=  load_decoder(ta_checkpoint["target"]["decoder"],  __A							)

      UpperCAmelCase__								=  OnnxRuntimeModel.from_pretrained("kashif/soundstream_mel_decoder"							)

      UpperCAmelCase__								=  SpectrogramDiffusionPipeline(
          notes_encoder=__A,  continuous_encoder=__A,  decoder=__A,  scheduler=__A,  melgan=__A,  )
      if args.save:
            pipe.save_pretrained(args.output_path							)


if __name__ == "__main__":
      UpperCamelCase__											=					argparse.ArgumentParser()

      parser.add_argument('--output_path', default=None, type=str, required=True, help='Path to the converted model.')
      parser.add_argument(
          '--save', default=True, type=bool, required=False, help='Whether to save the converted model or not.'
      )
      parser.add_argument(
          '--checkpoint_path',
          default=f'''{MODEL}/checkpoint_500000''',
          type=str,
          required=False,
          help='Path to the original jax model checkpoint.',
      )
      UpperCamelCase__											=					parser.parse_args()

      main(args)



